Feint: learn, develop and test the cloud without a cloud account

You are learning Terraform (the tool that describes cloud infrastructure in files), developing a module, or you want to run your infrastructure tests in continuous integration without putting a single access key in them. Feint runs the Scaleway, Outscale and Exoscale APIs on your machine. Your real clients and your real Terraform providers talk to 127.0.0.1 instead of creating billed resources.

Concretely, the demonstration takes two commands, in a cloned repository, with nothing to configure:

feint up      # checks the host, starts the emulator, applies the Terraform
feint down    # destroys what it created, then stops the emulator

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

The provider that printed that line is the real one, from the Terraform registry, in its pinned version. No account was opened, no real credential was read, and nothing keeps running anywhere but on your own workstation.

Where to start, depending on what you want to do

In this course the path is short: install Feint, plug the official CLIs into it, then read what it proves and what it does not before drawing any conclusion from a local test. After that, depending on your goal, four guides extend the introduction: build my first infrastructure (five minutes, from nothing to a successful apply, an empty second plan and a clean destroy), learn Terraform without a credit card, test a real stack and test in CI with no credentials, on GitHub Actions and GitLab CI, with no cloud secret and nothing to clean up.

What Feint changes concretely

A team writing Scaleway Terraform or Outscale SDK code today tests against a paying account, or does not test. The first choice turns every continuous integration run into a line on the bill, and every developer into the owner of resources forgotten when a job failed halfway. The second lets errors reach production.

An emulator answers that precise need: it replays the provider's protocol so that the official client, the one you will really use, works without leaving your machine. This site already covers the AWS equivalent with Floci (in French); Feint does the same for the three European clouds, on a single port.

For a learner, the change is elsewhere and more radical: the loop of "I write, I apply, I break it, I fix it" becomes free and immediate, where it used to require a credit card, credentials and a few minutes of provisioning on every attempt.

What you can validate, and what you cannot

This is the question to ask before installing anything, and it has a written answer rather than a promise. In short: the API contract, the Terraform lifecycle and your client's behaviour are testable; pricing, quotas, real capacity and IAM permissions are not. Some answers depend on a machine runtime installed on the host. The page What Feint proves, and what it does not gives the complete matrix, verdict by verdict, with what establishes each one.

This is the most important limit to know before pointing an existing configuration here. Feint serves APIs locally; a client can compose the address of a product outside that perimeter itself, and its requests then leave for wherever they were going. The measured case is Object Storage: on a real stack, the same apply created its IP address on the emulator and carried on to s3.fr-par.scw.cloud.

The countermeasure is built in: run feint doctor from your stack's directory, and it reads your Terraform files and flags the known escape signatures before the apply.

ok    no known escape signature in the 1 Terraform file(s) here
      this checks the measured list (docs/limits.md), not every path a client could compose

The three ways to run it

The workstation route, and the only one that gives access to real machines, because those rely on a runtime installed on the host. Three channels lead to the same binary:

brew install stephrobert/feint/feint          # Homebrew
mise use -g github:stephrobert/feint@0.13.0   # mise, with attestation verification

The installation page covers the three channels, including the Sigstore signature-verified release, and says what each one checks before letting you run the binary.

Zero installation, control plane only. This is the form that serves in continuous integration.

docker run --rm -p 127.0.0.1:4599:4599 \
  ghcr.io/stephrobert/feint:v0.13.0@sha256:d46639ac7c7a0fa2b6b69d0c5d74bdca0757e3124675563209e8ada58e6a6040

It installs the published binary, verifies its checksum before running it, and waits until the emulator answers.

- uses: stephrobert/setup-feint@b7eba1d4fcaccf65cf9124bf97a0d995996709b9 # v1.0.0
  with:
    version: 0.13.0
    provider: scaleway

The state of the project, plainly

In 0.13.0, the emulator mounts 395 operations, of which 375 are driven by a real client in the reference run; the remaining 20 state, at their route, why no official client reaches them. The three providers are not at the same point.

Provider	Maturity	Operations	Proved by, in continuous integration
Scaleway	usable	191	Terraform, OpenTofu, `scw`
Exoscale	early	104	Terraform, OpenTofu, `exo`
Outscale	early	100	Terraform, OpenTofu, `octl`

Usable means a realistic configuration applies, re-plans empty and destroys. Early means the protocol is right and a real client drives a real workload, but that the surface is thinner. Since 0.13.0, Terraform drives all three providers: Exoscale joined the other two with version 0.71.0 of its provider, older versions still being refused for a reason that protects you, explained in the Terraform guide.

Key points

Feint serves the Scaleway, Outscale and Exoscale APIs locally, to learn, develop and test without an account or a bill.
It validates the API contract, the Terraform lifecycle and your client's behavior; not prices, quotas or IAM permissions.
A local run can still reach the real cloud: run feint doctor before apply.
The three providers are not equally mature: Scaleway is usable, Exoscale and Outscale are early.