Recommended Free Tools
Chef Infra lets you describe the desired state of servers as code and repeatedly converge machines to that state. The safest beginner path is to install Chef Workstation, create a version-controlled chef-repo and cookbook, write a small recipe, test it locally, and run Chef Infra Client in local mode. When several nodes need centralized policy and cookbook distribution, add a server-based workflow—but evaluate Chef 360 Platform first because Chef Infra Server is deprecated and scheduled to reach end of life in November 2026.
Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.
What Chef Infra does
Chef Infra is an infrastructure-as-code platform. Instead of changing each server by hand, you declare resources such as files, packages, services, users, and configuration templates in Ruby-based recipes. Chef Infra Client evaluates those declarations on a node and takes only the actions required to make the node match the declared state. This convergence model makes a change repeatable: if a file is removed or edited outside Chef, a later run can restore the version described by the recipe.
As an Amazon Associate I earn from qualifying purchases.
Free tools Windows power users keep installed
One-click scans. No signup required.
A cookbook is Chef’s basic distribution unit. A cookbook can contain recipes, attributes, custom resources, files, templates, Ohai plugins, and a metadata.rb file describing it and its dependencies. Recipes use Chef’s resource domain-specific language, so you express the desired result rather than writing a one-off shell script for every machine.
The three main Chef components
| Component | Where it runs | Primary responsibility |
|---|---|---|
| Chef Workstation | Your authoring and administration computer | Provides Chef Infra Client, Chef InSpec, Chef Habitat, the chef and knife command-line tools, Test Kitchen, Cookstyle, and related cookbook-development tools. You create repositories, resolve Policyfiles, test changes, and perform server operations here. |
| Chef Infra Client | Each managed node | Retrieves the configuration it needs and applies a run list or Policyfile locally, converging the node toward the declared state. |
| Chef Infra Server | Central service in a traditional deployment | Stores and distributes cookbooks, policies, and node metadata. Clients request the required data, then perform as much work as possible on the node. |
Keep the distinction clear: Workstation is the development and control surface, Client is the agent that changes a machine, and Server is the optional central hub. A workstation is not a replacement for the client on a production node.
#1 Best Overall
Before you install anything
Choose a learning target
Start with a disposable Linux virtual machine or another non-production system. Your first exercise should make one visible, reversible change, such as creating a text file. Once you understand a local run, you can move to packages, services, templates, and multiple nodes.
Prepare a source-controlled workspace
Chef’s setup guidance treats repository contents as source code. Plan to keep the repository in version control from the first commit. It should contain cookbooks, data bags when you use them, and Policyfiles. Review changes as code, tag known-good revisions, and do not mix untracked emergency edits into a deployment.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesSeparate learning from production credentials
Local mode does not require a central server account. For a server workflow, credentials and organization configuration are needed before you upload cookbooks or policies. Use separate credentials and environments for experiments and production, and limit access to the data a workstation or node actually needs.
Install Chef Workstation
Install Chef Workstation on the computer where you will write and test cookbooks. It bundles the client, InSpec for compliance tests, Habitat, command-line utilities, Test Kitchen for integration testing, Cookstyle for linting, and authoring support. Installing Workstation gives you one supported starting point instead of assembling each tool independently.
After installation, open a terminal and verify that the chef command is available. Keep Workstation updated according to the release guidance for the operating systems in your environment; the exact installer and supported platforms can change, so use the current Workstation documentation for those platform-specific details.
Create a chef-repo and your first cookbook
- Create the repository:
chef generate repo chef-repo. - Change into the new repository and inspect its generated directories. Keep cookbook code, data bags, and Policyfiles inside this repository so they can be reviewed and versioned together.
- Generate a cookbook:
chef generate cookbook new_cookbook. - Open
new_cookbook/recipes/default.rb. This is the default recipe that Chef will run when the cookbook is included in a run list or policy.
The generators create a conventional layout rather than a single script. That structure matters as the cookbook grows: metadata records dependencies, recipes describe behavior, resources can be extended with templates and files, and the generated testing files give you a place to catch errors before a node is changed.
Write a minimal recipe and observe convergence
For a first resource, create a file with explicit content:
file '/tmp/hello.txt' do
content 'Hello from Chef.n'
endThis declaration says that /tmp/hello.txt should exist with the specified content. It does not prescribe a sequence of shell commands. Chef determines whether an action is necessary and records the result in the run output.
Run the cookbook locally while learning:
chef-client --local-mode --override-runlist exampleThe quickstart example demonstrates the important behavior: Chef creates the file, recreates it after deletion, and restores the declared content after a manual edit. That is convergence in practice. The desired state remains in code, while the node can drift and be corrected by a subsequent run.
What to check after the first run
- Read the resource summary and confirm the file resource reported the expected action.
- Inspect the file and its content on the target machine.
- Run Chef again without changing the recipe. A converged resource should not be changed unnecessarily.
- Delete or edit the file deliberately, run Chef once more, and verify that the declared state is restored.
Use a harmless path for this exercise. Do not begin by managing authentication, firewall rules, or a production service; a syntax or ordering mistake in those areas can lock you out or interrupt an application.
Develop cookbooks as tested software
Lint the code
Cookstyle, included with Workstation, checks cookbook Ruby and style patterns. Linting catches issues such as malformed resource blocks and conventions that make a cookbook difficult to maintain. Run it during development and in your change review process rather than waiting for a deployment failure.
Use cookbook tests and a local VM
The current Workstation workflow combines cookbook tests, linting, a local virtual machine, Test Kitchen, and an InSpec profile. Test Kitchen exercises the cookbook against a real or virtual test instance, while InSpec verifies the resulting system from the outside. This catches errors that a Ruby syntax check cannot: missing packages, incorrect service behavior, file permissions, and assumptions about the target platform.
Keep tests focused on observable outcomes. For the file example, an integration check should verify that the path exists and contains the intended text. For a service cookbook, test that the package is installed, the configuration has the required setting, and the service is enabled and running. Destroy disposable test instances after a run so that stale state does not hide defects.
Promote changes through review
Commit the recipe and its tests together. Reviewers should be able to see what state changes, which platforms are supported, how dependencies are resolved, and what evidence the tests provide. Treat a cookbook release or policy revision as an auditable deployment artifact, not as an informal copy of a directory.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Local mode versus a centralized server
| Workflow | Best fit | Advantages | Trade-offs |
|---|---|---|---|
| Local mode | Learning, single machines, or tightly controlled standalone automation | Quick setup; no server credentials; the repository and node are enough to run a recipe. | You must distribute code, coordinate versions, and manage node results yourself as the number of systems grows. |
| Chef Infra Server | Existing organizations that need the traditional centralized Chef model | Cookbooks, policies, and node metadata are held centrally; clients retrieve the configuration they need. | Requires server administration, credentials, organization setup, and a lifecycle decision because the server is deprecated. |
For local learning, stay in local mode until you can generate, test, and safely change a cookbook. A centralized design becomes useful when many nodes need consistent distribution, role or environment coordination, and a shared record of what each node should consume.
How a server-based run works
- Develop and test the cookbook on Workstation.
- Configure the organization and credentials used by the
chefandknifetools. - Upload the cookbook or its policy data to the central service.
- Assign the appropriate run list or policy to a node group.
- Install and configure Chef Infra Client on each managed node.
- Allow the client to authenticate, retrieve the required recipes, templates, and files, and converge locally.
The server distributes data; it does not perform every configuration action on behalf of the node. The client requests what it needs and carries out the work on the managed system. Plan network access, authentication, node identity, and failure handling accordingly.
Run lists and Policyfiles: which model should you use?
Traditional run lists
A run list names the recipes or roles a node should run. This is familiar and flexible, especially in an established Chef installation. Its weakness is visibility: the complete dependency set may be assembled from several moving parts, making it harder to see exactly what a node will receive before a change.
Policyfiles
A Policyfile is a single, immutable definition of cookbooks, dependencies, and attributes. Workstation resolves the complete dependency set and writes Policyfile.lock.json. That lock file is uploaded and associated with a node group, so promotion can use the same resolved cookbook set rather than resolving dependencies afresh on every node.
| Decision axis | Run-list workflow | Policyfile workflow |
|---|---|---|
| Repeatability | Depends on the versions and sources resolved by the environment. | The lock file records the resolved set before clients run. |
| Reviewability | Changes can be spread across roles, environments, and cookbook constraints. | One policy and its lock file show the intended collection more directly. |
| Promotion safety | Requires careful coordination of cookbook versions and constraints. | Promote a tested, locked set between node groups. |
| Migration effort | Usually simpler for an existing installation. | Requires adopting Policyfile files and a policy-oriented operating model. |
For a new project, Policyfiles are usually the stronger default when you value dependency locking, reviewability, and predictable promotion. For an existing estate built around run lists, migrate incrementally: document the current behavior, create a policy for one node group, test it, and compare the resulting state before expanding the rollout.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Chef Infra Server’s 2026 lifecycle warning
The current Chef Infra Server overview states that “Chef Infra Server is deprecated and will reach end-of-life status in November 2026.” It identifies Chef 360 Platform as the current platform direction. This is a material architecture constraint, not a minor version note.
Best Value
If you already operate Chef Infra Server, inventory cookbooks, policies, node groups, integrations, credentials, and automation that depend on it. Establish how you will export or recreate that data, test client behavior, and preserve audit history. For a new deployment, compare the capabilities and migration path of Chef 360 Platform with your requirements before committing to a server-based design. Confirm current support and migration details with Chef/Progress because dates, tooling, and supported paths can change.
A practical first-month plan
Week one: learn the convergence loop
- Install Workstation.
- Generate
chef-repoandnew_cookbook. - Create the file resource and run it with local mode.
- Delete and edit the file, then verify correction.
Week two: make the cookbook maintainable
- Put the repository under version control.
- Replace hard-coded repetition with cookbook structure, attributes, templates, or custom resources only when a real need appears.
- Run Cookstyle and add tests for the behavior you depend on.
Weeks three and four: test promotion
- Run the cookbook through Test Kitchen and verify outcomes with InSpec.
- Write a Policyfile and inspect the generated lock file.
- Decide whether your node count and governance needs justify central distribution.
- If they do, prototype the server or Chef 360 path in a non-production environment and document rollback.
Common failure modes and recovery
The command cannot find a cookbook
Check that you are running from the repository or have supplied the correct cookbook path and run-list name. Confirm that the generated cookbook directory exists and that its default recipe is present.
The recipe runs but nothing changes
Read the resource output and compare the actual node state with the declaration. A resource that already matches its desired state should report no change. If you expected a change, inspect the exact path, package name, service name, attributes, and platform assumptions.
A test passes locally but fails in Test Kitchen
Look for undeclared dependencies on your workstation: an installed package, an existing directory, an environment variable, or a particular operating-system default. Make the dependency explicit in the cookbook or constrain the supported platform, then rerun the disposable instance.
A centralized client cannot converge
Separate authentication and connectivity problems from cookbook errors. Verify node credentials, organization configuration, network reachability, and that the required cookbook or policy was uploaded and assigned. Only after the client can retrieve its configuration should you debug the recipe itself.
What to do next
Repeat the small local exercise with a package and a service, then add a template and an integration test. Move to Policyfiles when you need a locked, reviewable dependency set. Introduce centralized distribution only after you have a tested cookbook and a clear lifecycle plan that accounts for Chef Infra Server’s November 2026 end of life.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
