O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Learning Path: Automation with Ansible, Puppet, and Salt

Video Description

Automation for Beginners

In Detail

Automation is the ability to orchestrate and integrate tools, people, and processes through a workflow. In this Learning Path, we will look at the most popular tools for automation their advantages, and how to automate effectively with each one of them. We'll cover the why and how of Ansible, Puppet, and Salt, in a step-by-step, progressive manner. Initially, we focus on Ansible. You will learn how to manage environments and implement strategies in Ansible and be introduced to Ansible Galaxy and Tower, which are Ansible's enterprise tooling for supporting large-scale infrastructure. We then move on to learning Puppet. Puppet is a configuration management tool that allows you to automate all your IT configurations. Using Puppet you can control each Puppet agent in a network. You will learn how to do so by first understanding the Puppet ecosystem and then detailed topics such as configuration and management of Puppet servers, environments, module repositories, and reusable modules. With Salt too, we use a similar approach. We start from the basics, such as installing, configuring, deploying, and managing a web application to advanced concepts like Docker containers across multiple systems behind a HAProxy load balancer.

By the end of this Learning Path, you will be able to build and manage your infrastructure and fully utilize its potential.

Prerequisites:

  • Basic idea of system administration and Linux systems
  • Workstation with Vagrant and VirtualBox installed
  • Resources: Code downloads and errata:

  • Ansible 2 for Beginners

  • Puppet Essentials for Beginners

  • Learning Salt

  • PATH PRODUCTS

    This path navigates across the following products (in sequential order):

  • Ansible 2 for Beginners (4h 21m)

  • Puppet Essentials for Beginners (3h 25m)

  • Learning Salt (6h 14m)

  • Table of Contents

    1. Chapter 1 : Ansible 2 for Beginners
      1. The Course Overview 00:04:26
      2. What Is Ansible? 00:03:30
      3. Why Ansible? 00:03:09
      4. Demonstration – From Bash to Ansible 00:19:28
      5. Course Layout 00:02:54
      6. Basic Ansible Vocabulary 00:02:53
      7. New Features in Ansible 2.0 00:03:31
      8. Creating an Ansible Home Base 00:03:03
      9. Installing Ansible 00:05:49
      10. Bleeding-Edge Ansible Installation 00:08:31
      11. Setting up our Test Environment 00:07:34
      12. Target Machine Requirements 00:03:07
      13. Ansible Configuration Hierarchy 00:05:16
      14. Ansible Hosts Inventory File 00:05:20
      15. Ad-Hoc Commands 00:07:55
      16. Introduction top playbooks 00:19:41
      17. Playbook Structure 00:11:16
      18. Introduction to Modules 00:06:01
      19. Common Modules 00:11:30
      20. Variables and Facts 00:17:56
      21. Real-Life Playbook: Mattermost Deployment 00:12:03
      22. Real-Life Playbook Walkthrough 00:14:44
      23. Debugging and Troubleshooting 00:13:07
      24. Conditionals and Control Flow 00:04:52
      25. Templating, Control Flow, and Iteration in Jinja2 00:07:37
      26. YAML Basics 00:04:37
      27. Ansible Blocks 00:03:59
      28. Performance and Execution Strategies 00:08:11
      29. Ansible Galaxy 00:04:59
      30. Security 00:04:13
      31. Ansible in the Cloud 00:03:01
      32. Ansible AWS Demo 00:25:11
      33. Ansible Tower 00:02:30
    2. Chapter 2 : Puppet Essentials for Beginners
      1. The Course Overview 00:04:45
      2. Installing and Setting Up the Working Environment 00:11:21
      3. Configuration Management and How Puppet Fits into the Scenario 00:04:58
      4. Puppet Components and Terminologies 00:04:59
      5. Understanding the Puppet Run Cycle 00:03:49
      6. Installing the Puppet Components 00:06:07
      7. Puppet in Action 00:08:29
      8. Overview of the Puppet Language 00:12:48
      9. Puppet Server in Production and Managing Certificates 00:09:43
      10. Introduction to Community Modules 00:07:16
      11. Managing Module Dependencies and librarian-puppet 00:05:22
      12. Managing Environments with r10k 00:14:08
      13. Understanding roles and Profiles 00:10:04
      14. Writing and Managing a Module 00:12:37
      15. Understanding and Using Hiera 00:13:38
      16. Overview of Module Testing 00:03:59
      17. Testing Puppet Syntax with puppet-lint 00:08:40
      18. Writing Unit Tests with rspec-puppet 00:16:00
      19. Writing Tests with Beaker Using Serverspec 00:09:38
      20. Writing Tests with test-kitchen Using Serverspec 00:09:49
      21. Publishing Modules to Puppet Forge with puppet-blacksmith 00:06:15
      22. Configuring and Using Jenkins to Run the Test Suites 00:07:13
      23. Using Jenkins to Create a Code Management Workflow 00:13:36
    3. Chapter 3 : Learning Salt
      1. The Course Overview 00:02:02
      2. The Philosophy of Salt 00:03:00
      3. How Salt Communicates? 00:07:14
      4. Installing Salt 00:05:18
      5. Configuring Salt 00:09:55
      6. Key Acceptance and Encryption 00:09:09
      7. Targeting Minions 00:10:20
      8. Execution Module Basics 00:14:06
      9. Common Execution Modules 00:16:26
      10. Call from Master or Minions 00:10:18
      11. The Philosophy of Salt's State System 00:06:06
      12. Our First State 00:14:22
      13. Dissect State Functions 00:11:35
      14. Execution Flow of a State Run 00:07:13
      15. Debugging States 00:05:17
      16. Introduction to YAML, Jinja, and Other Renderers 00:05:26
      17. How to Write Reusable States? 00:12:36
      18. How to Write Maintainable States? 00:17:39
      19. YAML and Jinja Best Practices and Gotchas 00:05:36
      20. Configuring States Using Pillar 00:20:11
      21. Learning Salt Formulas 00:09:10
      22. Debugging Jinja 00:05:36
      23. Glue SLS Files Together 00:09:48
      24. Defining, Enforcing, and Debugging Execution Orders 00:16:14
      25. Conditional and Branching Logic During a State Run 00:13:17
      26. Debugging a State Run 00:09:54
      27. Sharing Data between Systems with Salt Mine 00:06:43
      28. Using Salt Orchestrate to Manage Complex State Runs 00:09:00
      29. An Overview of Salt's Event Bus 00:05:19
      30. Sending Custom Events 00:06:22
      31. Listening to Events and Trigger Actions with Salt's Reactor 00:12:04
      32. Integrating Salt with External Tools Using Events 00:05:33
      33. Sending Events Using Beacon Modules 00:09:46
      34. How to Debug the Reactor and Best Practices? 00:04:54
      35. Installing and Configuring Salt-API 00:13:34
      36. Exploring rest_cherrypy 00:14:47
      37. More rest_cherrypy Features 00:15:05
      38. Using Salt-API to Integrate with External Systems 00:10:23
      39. Wrapping Up and Further Scope 00:03:15