How do node attribute references work in the generated recipe?

If you fill in an attribute path like `nginx.package_name`, the generator renders the resource's name as `node['nginx']['package_name']` instead of a literal string, matching how Chef recipes commonly pull configurable values from a cookbook's `attributes/default.rb` file rather than hardcoding them.

What actions are valid for each resource type?

It depends on the resource: `package` typically uses `:install`, `:upgrade`, `:remove`, or `:purge`; `service` uses `:start`, `:stop`, `:restart`, `:enable`, or `:disable`; `template` and `file` typically use `:create`, `:create_if_missing`, `:delete`, or `:touch`. The generator accepts any lowercase, underscore-safe action string so it isn't limited to this list, but these are Chef's conventional ones.

Why does the template resource add a source line automatically?

A Chef `template` resource always needs a `source` pointing at an ERB file in the cookbook's `templates/` directory; the generator derives a reasonable ` .erb` from the resource's path so the block is immediately structurally complete, though you'll likely rename it to match your actual template file.

Is this recipe ready to run with chef-client?

It's a syntactically correct set of resource blocks using Chef's real Ruby DSL, but a runnable recipe also needs to live inside a cookbook with a metadata.rb, and any templates/attributes referenced need to actually exist in that cookbook's directory structure.

Chef Recipe Generator - recipe.rb Builder

Overview

Introduction

Chef recipes are plain Ruby, which is powerful but means there's no fixed template to fill in, just resource blocks with a type, a name, and an action, written by hand every time.

This tool generates a recipe.rb from repeatable resource rows, each rendered as a correctly formatted Chef resource block, including the `node[...]` attribute lookup pattern when you need a resource's name to come from cookbook attributes rather than a hardcoded string.

What Is Chef Recipe Generator?

A Chef recipe generator supporting the four most common resource types, package, service, template, and file, each configured with a name (or attribute path), an action, and rendered as a valid Ruby DSL block.

When a row specifies an attribute path (e.g. `nginx.package_name`), the resource's identifier renders as a nested `node['nginx']['package_name']` lookup instead of a plain string literal.

How Chef Recipe Generator Works

For each resource row, you choose a resource type, a name (used as the literal resource identifier unless an attribute path is given), and an action.

The tool renders each as `<type> <name_expression> do ... action :<action> end`, adding a `source` line automatically for template resources, and converts any provided attribute path into Chef's bracketed `node['a']['b']` lookup syntax.

When To Use Chef Recipe Generator

Use it when scaffolding a new cookbook's recipe and you want correctly formatted resource blocks for the common package/service/template/file pattern.

It's also useful for demonstrating the difference between hardcoding a resource name and pulling it from `node[...]` attributes, a common Chef convention for configurable cookbooks.

Often used alongside Ansible Playbook Generator and Puppet Manifest Generator.

Features

Advantages

Correctly renders Chef's `node['a']['b']` bracketed attribute lookup syntax from a simple dot-path input, rather than requiring you to type the brackets and quotes by hand.
Covers the four resource types that make up the overwhelming majority of real-world recipes.
Validates that every resource has a valid Ruby-symbol-safe action before generating output.

Limitations

Doesn't support Chef's more advanced resource properties (guards like `only_if`/`not_if`, `notifies`/`subscribes` between resources), only the name and action.
The template resource's auto-derived `source` filename is a reasonable guess, not guaranteed to match an actual file in your cookbook's `templates/` directory.

Examples

Installing nginx by attribute and restarting it

Input

resources: [{type: package, name: nginx, attributePath: nginx.package_name, action: install}, {type: service, name: nginx, action: restart}]

Output

package node['nginx']['package_name'] do
  action :install
end

service 'nginx' do
  action :restart
end

The package resource pulls its name from node attributes (nginx.package_name), while the service resource uses the literal name since no attribute path was given.

Best Practices & Notes

Best Practices

Prefer `node[...]` attribute references over hardcoded names for anything that might differ by platform or environment (package names often do between Debian and RHEL families).
Use `notifies`/`subscribes` (added by hand after generation) instead of separate independent resources when one resource's change should trigger another, Chef's equivalent of Ansible's handler pattern.
Keep one resource type's concerns together (e.g. all package installs before the services that depend on them) for readability, even though Chef resolves dependencies via the resource collection, not file order alone.

Developer Notes

Attribute path conversion splits the input on `.` or `/` and joins each segment as `['segment']`, matching Chef's real attribute-access syntax (`node['nginx']['package_name']`), which under the hood is Chef::Node::ImmutableMash's bracket accessor; actions are validated against a permissive `^[a-z_]+$` pattern rather than a fixed enum, since Chef resources define their own valid action symbols per resource type rather than sharing one global list.

Chef Recipe Generator Use Cases

Scaffolding a new cookbook recipe's package/service/template/file resources
Demonstrating Chef's node attribute lookup pattern for configurable resource names
Producing a consistent recipe structure across a team's cookbooks

Common Mistakes

Hardcoding a package name that differs across the platforms the cookbook targets, instead of pulling it from a platform-aware attribute.
Forgetting that a generated template resource's `source` filename is a placeholder guess, not an existing file, until you create it in templates/.

Tips

Use the Ansible Playbook Generator or Puppet Manifest Generator instead if your infrastructure targets one of those configuration management tools rather than Chef.

Chef Recipe Generator