Courses Solutions Case Studies & Testimonials News & Insights About Us Contact Us
Public Sector Graduate Training Schemes Learning & Development Corporate & Volume Pricing Custom Learning Paths

Public Sector

We've had the pleasure of working with UK and overseas central and local government departments, including Healthcare (NHS and Foundation Trusts), Defence, Education (Universities and colleges), many of the main Civil Service departments, Emergency Services; also public-owned corporations including the BBC, Bank of England, Ordnance Survey, and regulatory bodies such as Ofgem.

We are registered on Crown Commercial Service’s (CCS) Dynamic Purchasing System (RM6219 Training and Learning) and also with numerous tender portals such as Ariba, Coupa and Delta E-Sourcing.

Read more...

Graduate Training Schemes

Framework Training has a strong track record of providing a solid introduction into the working world for technical graduates across myriad industries. We provide the opportunity to learn and gain valuable hands-on experience in a supportive, friendly and sociable training environment.

Attract & retain the brightest new starters

We know it is vital for our clients to invest in the future of their talented grads; not only to provide them with high-quality, professional training essential for their roles, but to embed them within the organisation’s culture and guide them on the right path to a successful career.

After all, your new hires could well be the next leaders and their creative ideas and unique insights are invaluable to your business.

Read more ...

Learning & Development

Our unique portfolio of high-quality technical courses and training programmes are industry-respected. They’re carefully designed so that delegates can seamlessly apply what they’ve learnt back in the workplace. Our team of domain experts, trainers, and support teams know our field — and all things tech — inside out, and we work hard to keep ourselves up to speed with the latest innovations. 

We’re proud to develop and deliver innovative learning solutions that actually work and make a tangible difference to your people and your business, driving through positive lasting change. Our training courses and programmes are human-centred. Everything we do is underpinned by our commitment to continuous improvement and learning and generally making things much better.

Read more...

Corporate & Volume Pricing

Whether you are looking to book multiple places on public scheduled courses (attended remotely or in our training centres in London) or planning private courses for a team within your organisation, we will be happy to discuss preferential pricing which maximise your staff education budget.

Enquire today about:

  • Training programme pricing models  

  • Multi-course voucher schemes

Read more...

Custom Learning Paths

We understand that your team training needs don't always fit into a "one size fits all" mould, and we're very happy to explore ways in which we can tailor a bespoke learning path to fit your learning needs.

Find out about how we can customise everything from short overviews, intensive workshops, and wider training programmes that give you coverage of the most relevant topics based on what your staff need to excel in their roles.

Read more...

Puppet for Developers: Automation, Testing & CI/CD

From code to production: Puppet skills for the modern developer.

About the course

Modern software development demands efficient and automated processes from coding to deployment. For developers, ensuring consistent application environments and managing complex dependencies across various stages is a significant challenge. This 3-day course is specifically tailored for software developers, providing the practical skills to effectively leverage Puppet for automating application environments, managing dependencies, and streamlining the path to deployment using current tools and best practices relevant to their workflow.

The course establishes how Puppet fits into a developer's world, starting with setting up a practical local development and testing environment using Vagrant. Participants will gain hands-on experience writing, validating, and managing Puppet code using the Puppet Development Kit (PDK), the standard tool for building reusable and well-structured modules. A key focus is placed on organising Puppet code effectively using the Roles and Profiles pattern and managing application-specific configuration data flexibly using Hiera, enabling the creation of reusable modules that can be configured via data. Crucially, the course integrates practical techniques for testing Puppet code, including linting, validation, and unit testing with PDK.

Beyond core configuration management, the workshop introduces Puppet Bolt for ad-hoc automation, scripting, and orchestrating deployment tasks directly from a developer's workstation, providing powerful capabilities that complement the agent-based CM. Participants will explore practical patterns for using Puppet to manage application dependencies, deploy application files, and manage services. The course concludes by discussing how Puppet code integrates with Version Control (Git) and fits into CI/CD pipelines, along with essential troubleshooting and security considerations relevant to developers, equipping attendees with the skills to automate their application infrastructure effectively.

Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.

    • Understand how Puppet automates application environments and dependencies.
    • Set up a local development and testing environment using Vagrant and Puppet.
    • Write and apply Puppet code using resources and language constructs for application components.
    • Use the Puppet Development Kit (PDK) to create, validate, and manage Puppet modules.
    • Implement the Roles and Profiles pattern to structure application configurations for scalability and reusability.
    • Manage application configuration data using Hiera and integrate it with Puppet code.
    • Apply testing concepts and tools (PDK validation/unit tests) to ensure Puppet code quality.
    • Utilise Puppet Bolt for ad-hoc automation and orchestrating application deployment tasks.
    • Develop patterns for using Puppet to deploy and manage applications and their dependencies.
    • Understand how Puppet integrates with Version Control and CI/CD pipelines.

  • This 3-day course is designed for Software Developers, DevOps Engineers, and anyone involved in the development, deployment, and management of applications who wants to leverage Puppet for automating application environments and dependencies. It is ideal for:

    • Developers seeking to automate the setup and configuration of development, testing, and production environments.

    • Teams looking to integrate infrastructure automation into their application development and deployment workflows.

    • Developers who need to write, understand, and manage Puppet code for application dependencies and configuration.

    • DevOps engineers wanting to deepen their skills in using modern Puppet tools (PDK, Bolt) and practices (Roles/Profiles, Hiera, Testing) for application automation.

  • Participants should have:

    • A basic understanding of software development concepts and practices.

    • Familiarity with command-line interfaces.

    • Experience using a version control system, preferably Git.

    • A foundational understanding of Linux operating systems.

    No prior experience with Puppet, Puppet Enterprise, or other configuration management tools is strictly required, although some exposure would be beneficial.

    We can customise the training to match your team's experience and needs - with more time and coverage of fundamentals for new developers, for instance.

  • This Puppet course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).

    Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.

  • Introduction to Puppet for Developers & Local Setup

    • Why Automation and Configuration Management for Developers? (Consistent environments, dependency management, faster deployments).

    • Introduction to Puppet: What it is, its role in automating application environments.

    • Puppet Architecture Overview (Agent/Server model and its relevance to developers).

    • Introduction to the Puppet Ecosystem (Agent, Server, Forge, PDK, Bolt).

    • Setting up a Local Development Environment:

      • Introduction to Vagrant: Why it's useful for developers testing Puppet code.

      • Installing and configuring Vagrant.

      • Creating and managing virtual machines with Vagrant.

    • Hands-On Lab: Setting up Vagrant, creating a basic virtual machine, exploring the local environment, installing Puppet Agent on the VM.

    Writing Puppet Code - Resources & Language Constructs

    • The Puppet Language (DSL) Basics: Syntax and structure.

    • The Resource Abstraction Layer (RAL): Managing system state.

    • Common Resource Types for Application Management: package, file, service, exec, user, group, cron, mount.

    • Defining Resources: Titles, attributes, parameters.

    • Resource Relationships: Managing dependencies (require, before, ~>, notify, subscribe).

    • Using Variables and Facts: Accessing node-specific data via Facter (e.g., OS family, memory, custom application-related facts).

    • Conditional Logic: if, unless, case.

    • Loops and Iteration (each).

    • Hands-On Lab: Writing basic Puppet manifests to manage common resources on a Vagrant VM (e.g., install a web server package, ensure a configuration file exists), applying manifests with puppet apply, practicing resource relationships and conditionals.

    Building Modules with PDK - The Developer Workflow

    • What are Modules? Encapsulating reusable Puppet code and data for applications/services.

    • The Standard Module Structure (manifests, files, templates, data, tasks, plans, spec, types).

    • Using Modules from the Puppet Forge: Finding and installing pre-built modules (puppet module install).

    • Introduction to the Puppet Development Kit (PDK): Why PDK is essential for developers (scaffolding, validation, testing).

    • Installing and configuring PDK.

    • Creating a New Module using pdk new module.

    • Adding Classes and Defined Types to a Module using PDK templates.

    • Understanding and editing metadata.json.

    • Hands-On Lab: Installing PDK, creating a new module using PDK for a simple application component, adding classes/defines using PDK templates, exploring the PDK-generated structure.

    Data Management & Code Structure - Hiera, Roles & Profiles

    • The Need for Data Separation for Developers: Making code reusable across different environments and applications.

    • Introduction to Hiera: Puppet's data lookup system.

    • Hiera 5 Configuration (hiera.yaml): Defining data hierarchies (e.g., based on environment, application name, tier).

    • Data Backends: Using YAML and other common backends (overview).

    • Defining Data in Hiera: Creating data files for application configurations and settings.

    • Lookup Functions: Using lookup(), hiera(), etc. in modules and manifests.

    • Introduction to the Roles and Profiles Pattern: Structuring Puppet code for clarity and reusability in application environments.

    • Implementing Profiles (configuring a single application component or service layer).

    • Implementing Roles (composing profiles to define a server's full configuration, e.g., role::application_server).

    • Integrating Hiera with Roles and Profiles.

    • Hands-On Lab: Setting up Hiera in the Vagrant environment, defining a hierarchy and data files for a simple application, integrating Hiera lookups into module classes/defines, applying the Roles and Profiles pattern.

    Ensuring Code Quality - Testing Puppet Code

    • Why Testing Puppet Code is Crucial for Developers (ensuring idempotency, preventing regressions, verifying desired state).

    • Code Validation and Linting with PDK: Using pdk validate for syntax, style, and metadata checks.

    • Introduction to Unit Testing Concepts: Testing the logic of your Puppet code in isolation.

    • Writing and Running Basic Unit Tests with PDK (using rspec-puppet for resources and classes).

    • Introduction to Acceptance Testing Concepts: Testing the final state applied to a system (overview of tools like Litmus, testing against real VMs/containers).

    • Hands-On Lab: Using PDK to validate and lint a module, writing and running basic unit tests for a Puppet class/define using PDK.

    Automating Tasks & Deployments with Puppet Bolt

    • Introduction to Puppet Bolt: Agentless automation for developers.

    • Agent-based Configuration Management vs. Agentless Task Execution: Understanding when to use each (e.g., CM for ongoing state, Bolt for one-off actions or orchestrated sequences).

    • Installing and configuring Bolt.

    • Defining Bolt targets (inventory file).

    • Running Commands and Scripts with Bolt on target nodes.

    • Using Bolt Tasks: Running pre-built tasks from the Forge (e.g., restarting an application, running a database query, collecting application logs).

    • Writing Simple Bolt Tasks (e.g., a script to deploy a new application version, a task to check a service status).

    • Introduction to Bolt Plans: Orchestrating sequences of tasks, commands, and even Puppet runs (basic concepts for deployment workflows).

    • Hands-On Lab: Installing Bolt, defining targets in an inventory, running ad-hoc commands/scripts, executing a pre-built task, writing and running a simple custom task related to application deployment.

    Application Deployment Patterns with Puppet

    • Using Puppet to manage Application Dependencies (installing required packages, libraries, runtimes).

    • Managing Application Files and Configurations (using file resources, templates, Hiera for application configuration files).

    • Automating Application Deployment Steps (using exec resources for scripts, or orchestrating deployment with Bolt Plans).

    • Managing Application Services (ensuring the application process is running correctly with service resources).

    • Common Deployment Patterns with Puppet (e.g., deploying a simple web application from source or package, configuring a database client/user).

    • Hands-On Lab: Developing or extending a Puppet module (using PDK, Hiera, and Roles/Profiles) to deploy and configure a simple application and its dependencies on a Vagrant VM.

    Code Management, CI/CD & Collaboration

    • Version Control with Git: Best practices for managing Puppet code repositories (control repository, module repositories), branching strategies, pull requests, code review workflows relevant to Puppet code.

    • Introduction to Puppet Environments: Managing different versions of your Puppet code (development, testing, production environments).

    • Code Management Tools: Overview of r10k and Code Manager (Puppet Enterprise) for deploying code from Git to environments.

    • Integrating Puppet into CI/CD Pipelines: Concepts for automating validation, linting, testing (PDK), and triggering Puppet code deployment or Bolt plans as part of a CI/CD workflow.

    • Hands-On Lab: Setting up a Git repository for a control repo and modules, practicing a Git workflow for making changes, demonstrating a basic r10k workflow (or equivalent) for deploying code to environments.

    Troubleshooting, Security & Next Steps

    • Troubleshooting Puppet Runs from a Developer's Perspective: Using debug flags (-t --debug), checking agent and server logs (relevant for application issues), using puppet resource to inspect the state of resources managed by Puppet.

    • Troubleshooting Hiera Lookups (puppet lookup).

    • Troubleshooting Bolt Runs.

    • Basic Security Considerations for Developers: Managing sensitive application data (passwords, API keys) using Hiera backends like eyaml (overview), managing certificates.

    • Puppet in the Broader Ecosystem: How Puppet fits with IaC (Terraform), CI/CD tools, monitoring, and application deployment tools.

    • Finding Help and Resources: Puppet documentation, Forge, community forums, Slack channels.

    • Staying Updated in the Puppet and Automation Landscape.

    • Hands-On Lab: Practicing troubleshooting scenarios related to application deployment code on Vagrant VMs, using debug output, logs, puppet resource, and puppet lookup.

    • Puppet Documentation: The official source for the Puppet language reference and core components (Agent, Server), useful for understanding resource types and functions. https://puppet.com/docs/puppet/latest/

    • Puppet Bolt Documentation: Official guide for installing, configuring, and using Puppet Bolt for ad-hoc task execution and orchestration, highly relevant for deployment tasks. https://puppet.com/docs/bolt/latest/

    • Puppet Development Kit (PDK) Documentation: Official documentation for installing and using the PDK for Puppet module development, validation, and testing workflows. https://puppet.com/docs/pdk/latest/

    • Hiera Documentation: Detailed documentation on configuring and using Hiera for data separation, essential for building reusable application configurations. https://puppet.com/docs/puppet/latest/hiera.html

    • Puppet Forge: The primary repository for finding, using, and contributing reusable Puppet modules, including those for common applications and services. https://forge.puppet.com/

    • Puppet Community Forum/Slack: Connect with other Puppet users and developers, ask questions, and share knowledge. https://community.puppet.com/

Trusted by

CERN organisation logo AMEC company logo

Public Courses Dates and Rates

Please get in touch for pricing and availability.

Related courses