Chef
Deploy new code faster and more frequently.
About Chef
Automation for all of your technology. Overcome the complexity and rapidly ship your infrastructure and apps anywhere with automation.
Chef is the automation platform for DevOps. Achieve speed, scale and consistency by automating configuration and systems management.
- Consistently Configure and Apply Patches in Any Environment
- Ensure That Your Apps and Infrastructure are Always Secure and Compliant
- Modernize Your Legacy Applications Without Replacing or Rewriting Them
Chef Topics
The following are the things covered under Chef.
Getting started with Learn Chef Rally
Get a brief overview of Learn Chef Rally and learn how to earn badges, set up a curriculum, and reach out to the community.
Learn the Chef basics
Get started by using Chef to keep your servers in line with the configuration policies you describe.
Manage a node with Chef server
Learn how the Chef server acts as a central repository for your cookbooks and for information about your servers, or nodes.
Get started with Test Kitchen
Learn how to speed up the development process by using Test Kitchen to apply your infrastructure code from your workstation.
Go beyond the basics
Learn what happens behind the scenes when chef-client runs.
Keep your Chef cookbooks up to date
Learn how to update your cookbooks to make use of the latest Chef features and improvements.
Course Contents
The following are the course contents offered for Chef
- Terminology
- Working with Chef
- Installing chef-solo
- The Ruby gem
- Managing gems
- Verifying that chef-solo works
- Installing a Chef server
- Requirements and recent changes
- Installation requirements
- What you will be installing
- Getting the installer
- Installation outline
- Installing on Ubuntu
- Downloading the package
- Installing the package
- Installing on Red Hat Enterprise Linux
- Downloading the package
- Configuring a Chef server
- Understanding how chef-server-ctl works
- What's happening on my server?
- Verifying that the services are running
- Validating that your service is working
- Ensuring that your knife configuration works
- Getting to know Chef
- Modeling your infrastructure
- Roles
- Defining roles
- A web application service role
- An image-processing role
- An image search role
- A PostgreSQL service role
- A Solr service role
- An OpenSSH service role
- Implementing a role
- Determining which recipes you need
- Installing a cookbook
- Applying recipes to roles
- Mapping your roles to nodes
- Converging a node
- Environments
- Organizing your configuration data
- Example attribute data
- Data bags
- Knowing when to use data bags
- Large-scale infrastructure
- Leveraging the cloud
- Amazon EC2
- Installing the EC2 knife plugin
- Setting up EC2 authentication
- Provisioning an instance
- Bootstrapping the instance
- Terminating the instance
- Removing the Chef node
- Rackspace Cloud
- Provisioning an instance
- Terminating an instance
- Removing the Chef node
- Attributes
- Multiple attribute files
- Supporting multiple platforms
- Loading external attributes
- Using attributes
- Metadata
- Recipes
- Resources
- Using resources
- Overriding a default behavior
- Templates
- Why use templates?
- A quick ERB primer
- Executing Ruby
- Variable replacement
- The template resource
- The template variables
- Passing variables to a template
- Accessing computed configurations
- Searching for templates
- Definitions
- Recipes
- Developing recipes
- Writing recipes
- Starting out small
- Installing a simple service
- Getting more advanced
- Testing recipes
- RSpec
- RSpec and ChefSpec
- Testing basics
- Comparing RSpec with other testing libraries
- Using ChefSpec
- Getting started with ChefSpec
- Installing ChefSpec
- Locking your dependencies in Ruby
- Creating a simple recipe and a matching ChefSpec test
- Writing a ChefSpec test
- Building your recipe
- Executing tests
- Understanding failures
- Expanding your tests
- Multiple examples in a spec test
- Testing for multiple platforms
- Describing the setup
- Deploying software with Chef
- Configuring your local environment
- Modeling a simple Python application
- Managing the cookbooks
- Downloading cookbooks
- Looking at the database recipe
- Looking at your application deployment cookbook
- Preparing the directories
- Constructing your Python virtual environment
- Checking the source code
- Installing any extra dependencies
- Managing dependencies in Chef
- Managing dependencies elsewhere
- Using Python's requirements file
- Configuring your application
- Keeping your application running
- Defining roles
- Creating the base server role
- Creating the database server role
- Creating the web server role
- Adding users
- Provisioning EC2 instances
- Configuring the database host
- Configuring the web server
- Deploying your software
- Manually deploying updates
- Automating deployment
- Managing users
- Evolution of a shell user recipe
- Storing data in data bags
- Creating a data bag for users
- Searching for data
- Searching inside recipes
- Enhancing your user cookbook
- Distributing SSH keys
- Templating the authorized keys
- Adding deployment keys
- Writing custom extensions
- Developing a custom definition
- Organizing your code
- Writing a definition for using PIP
- Defining a full application template
- Building a resource
- Defining the resource
- Implementing the provider
- Modifying resources
- Loading an existing resource
- Declaring that a resource was updated
- Working with data bags
- Securing your data bags
- Secret keys
- Encrypting your data
- Decrypting your data
- Storing keys on nodes
- Searching your data
- Searching your data bags with knife
- Searching your data bags from a recipe
- Querying your data
- Managing multiple machines with search queries
- Vagrant and Chef-solo
- Installing Vagrant
- Provisioning a new host with Vagrant
- Booting your Vagrant image
- Combining Vagrant with Chef-solo
- Understanding the limitations of Chef-solo
- Configuring Chef-solo
- Telling Chef-solo what to run
- Using roles and data bags with Chef-solo
- Injecting custom JSON data
- Providing a custom node name
- Getting to know the Chef shell
- Using the Chef shell
- The standalone mode
- The solo mode
- The client mode
- Interacting with the Chef server using the shell
- Interacting with data
- Searching your data
- Editing your data
- Transforming data
- Executing recipes with Chef shell
- Creating a recipe in the shell
- Defining node attributes
- Setting attributes
- Accessing attributes
- Using configuration blocks
- Interactively executing recipes
- Debugging with the Chef shell
- Using the breakpoint resource
- Integration testing
- Using Test Kitchen
- Installing Test Kitchen
- Testing with Test Kitchen
- Building a simple cookbook
- Preparing your cookbook for the kitchen
- Testing your new cookbook
- Provisioning the instance
- Converging the newly created instance
- Writing a simple test
- Combining all the steps
- Extending Chef
- Writing an Ohai plugin
- A note about writing Ohai plugins
- Chef with Capistrano
- Automation and integration
- Automated updates and deployments
Download
Download Chef course plan