Course Taxonomy: Technology Platforms

Zero Trust Security Boot Camp

Posted on November 9, 2021 by -

Part 1:

  • Introductions
  • Brief Evolution of IT Security
  • The Perimeter Model
  • Brief Threat Landscape History
  • Problems with the Traditional Model
  • Brief History of Zero Trust
  • Zero Trust AuthN & AuthZ
  • Zero Trust Tenants
  • Zero Trust Basic Concepts
    • Team Knowledge Check

Part 2:

  • Zero Trust Network Design Part 1
  • Zero Trust 5 Steps of Transformation
  • Zero Trust Threats
    • Team Knowledge Check
  • Zero Trust Access Control
    • Mid-Team Quiz
  • Zero Trust Risk Management
  • Zero Trust Governance
  • Zero Trust Vendor Selection
    • Team Knowledge Check
  • Zero Trust Reference Architecture
    • Team Knowledge Check

Part 3:

  • Zero Trust Network Design Part 2
    • Team Knowledge Check
  • Zero Trust Implementation
    • Team Knowledge Check
  • Zero Trust Migration
  • Zero Trust Challenges
    • Team Knowledge Check
  • Zero Trust Wrap Up
    • Final Team Quiz
  • Ending- Bonus

GitLab for Project Managers

Posted on October 21, 2021 by -

Part 1: GitLab Overview and Organization

  • GitLab Workflow Components
  • Planning a Project
  • The Plan Stage: Project Management
  • GitLab Organization – Groups, Projects, and Issues, oh my!

Part 2: GitLab Plan Stage

  • Organizing the Work
  • Planning the Work
  • Doing the Work
  • Document the Work
  • GitLab Agile Planning Structures

Part 3: Planning Functions in GitLab

  • Issues: The Starting Point for your Workflow
  • Issues Keep Everyone Connected and Synchronized
  • What Can you Expect on an Issue Page?
  • Hands-On Lab: Issues and Labels
  • Hands-On Lab: Quick Actions
  • Why Milestones are Important
  • The Use of Kanban Boards
  • GitLab's Service Desk
  • Utilizing Wikis
  • Hands-On Lab: Create a Wiki Page
  • Hands-On Lab: Epics and Kanban Boards
  • Project Management Review Quiz
  • Hands-On Lab: Practice Lab 1
  • Hands-On Lab: Practice Lab 2

GitOps Boot Camp

Posted on June 25, 2021 by -

Part 1: Introduction

  1. Required knowledge
    1. Git: Committing code and creating pull requests
    2. Kubernetes: Deploying a service to Kubernetes and basic checks with kubectl
    3. Docker: Pushing an image to a Docker repository
    4. CI/CD: GitOps reverses the traditional understanding of continuous integration/continuous development.
  2. Core concepts: A quick introduction
    1. Immutable infrastructure
    2. Infrastructure as code
    3. Orchestration
    4. Convergence
    5. CI/CD
  3. What GitOps is not
    1. GitOps is not infrastructure as code.
    2. GitOps doesn't replace continuous integration (CI).
  4. The use case: Deploying a highly available microservice
    1. Deploying a microservice to Kubernetes, with all the surrounding infrastructure to make it available

Part 2: Setting up the Tools

  1. Kubernetes
    1. In advance: Setting up a cluster from scratch is time-consuming, even if you use a managed solution like EKS. Pre-allocating a cluster per person is something you can do in advance.
  2. Preparation: Setting up kubectl
    1. Every participant should have credentials to connect to the cluster using kubectl.
  3. Preparation: Access a cluster through kubectl/k9s.
    1. Check running pods.
      1. Check deployments.
  4. Repository
  5. Preparation: Infrastructure repository
    1. An empty repository in GitHub/GitLab to use for deploying infrastructure
  6. Application repository
    1. Strictly speaking, you don't need to separate the application and infrastructure, but it's easier to understand what goes where this way.
      1. A sample application that serves a web server with a hello world response as the baseline (NodeJS-based, for instance)
  7. ArgoCD
  8. Why ArgoCD?
    1. ArgoCD is tightly integrated with Kubernetes and closely follows the GitOps mindset. Therefore, it's a good tool to showcase GitOps.
  9. Exercise: Add ArgoCD to the cluster.
    1. Create namespace.
    2. Deploy ArgoCD to the cluster.
    3. Access ArgoCD using the CLI.

Part 3: Deploying a Microservice

  1. Exercise: Prepare a simple microservice to be deployed in k8s.
    1. Build sample application as a Docker container (Dockerfile can be provided in advance)
    2. Push service to a Docker registry (cloud-native, docker.io, or quay.io)
  2. Exercise: Create a k8s deployment.
    1. Create a Kubernetes deployment definition in code for the application (here's a sample).
    2. Push code to infrastructure repository.
    3. Create an application in ArgoCD.
    4. This time, you'll use the ArgoCD CLI so you can see that part. You'll move to use Git from here on, which is more aligned to GitOps.
    5. Sync the application.
    6. Again, use the CLI.
    7. Test: Use kubectl check to ensure that deployment works.
  3. Automated synchronization
    1. Pull versus push: How ArgoCD can read from a repository and automatically apply the changes
    2. Exercise: Activate synchronization so that further changes happen when you push code to the infrastructure repository.
  4. Exercise: Create a k8s service. (A deployment alone doesn't expose the microservice, so let's build on that.)
    1. Create service definition.
  5. Pull request
    1. This is an opportunity to introduce the pull request aspect of the flow. You can extend pull requests so that extra checks are performed, using something like GitHub Actions.
      1. Implementing CI with something like GitHub Actions isn't part of the exercise, although it's something that you can complete as an extra exercise. (See the bonus section at the end of this post.)
      2. Test: Carry out a kubectl check to prove that service was deployed.
  6. Exercise: Create a load balancer. (You still can't access service from the outside.)
    1. Create loadbalancer k8s definition for cloud provider.
    2. Pull request
    3. Test: Curl to load balancer address to ensure that service is actually online.
  7. Exercise: Update the application.
    1. Change something in the application, such as the body of the response of a route in the application.
    2. Rebuild container with a new tag and push it to Docker registry.
    3. Update k8s deployment to use new tag.
    4. Pull request
    5. Test: New version of the app should be deployed.
  8. Exercise: Update the infrastructure. (Why do this? So you can demonstrate that changing the application and the infrastructure results in blurry boundaries.)
    1. Update k8s deployment to be highly available (more than one replica).
    2. Pull request
    3. Test: kubectl shows that there are multiple pods running.
  9. Wrap-up: This covers the workflow of deploying an application and then performing updates and changes on it.
    1. This is the core of GitOps!
    2. There are also other, more advanced use cases to cover.

Part 4: Promoting Changes Through Different Environments 

  1. In advance: Prepare a second cluster.
    1. As with the first cluster, this is something to have prepared in advance.
  2. Preparation: Register the cluster in ArgoCD to allow deployments to it.
  3. From development to production
    1. Which options are there to represent different stages?
    2. This is an open discussion, as there's no set recipe to do environment promotion, with different options:
    3. Use different infrastructure repositories.
    4. Use different folders in the same infrastructure repository.
    5. Use branches.
  4. Exercise: Promotion of a version
    1. Set up a second cluster (production) to read from a different folder.
    2. Copy the infrastructure created for the first folder into this one.
    3. Pull request
    4. Test: Second cluster should have the service available as well.
  5. More advanced deployment scenarios (Controlled release is an important part of releasing traffic, especially to production. It's worth talking about the options that you have that can be based on the exact same building blocks as explained before.)
  6. Exercise: Blue/Green
    1. Enable Argo Rollouts in cluster.
      1. Test: Observe rolling deployment with kubectl.
    2. Install argo-rollouts plugin for kubectl.
    3. Create rollout to apply to existing microservice.
  7. Canary release
    1. Theory only (This can be a good lead-in to a discussion of the merits and tradeoffs of different deployment strategies.)
  8.  Exercise: Error handling (This exercise shows that failure in infra deployment is expected and is handled through code changes—not panicked actions!)
    1. Introduce an error in the hello world application (this results in a thrown exception instead of starting the webserver).
    2. Rebuild the container with a new tag and push it to Docker registry.
    3. Update k8s deployment to use new tag.
    4. Pull request
    5. Test: Confirm with kubectl that deployment is failing.
    6. Revert a failed change through code.

Part 4: Security in GitOps

  1. Accessing resources
    1. kubectl shouldn't replace observability, such as logging and monitoring (similar to secure shell—SSH—into a production server)
  2. Secrets
    1. No plaintext secrets should ever be stored in Git.
  3. Vault
    1. This is theory only because it's probably too much to do for a practical exercise.
  4. Exercise: Sealed secrets
    1. Depending on time, this can be treated as theory or as an exercise. Furthermore, you can split it in two depending on how much time you have.
      1. Modify microservice to read the secret and make it available through a request.
    2. Provision secrets in the infrastructure repository.
    3. Use secrets from either the cluster or the application.
    4. Install the sealed secrets controller.
    5. Inject an encrypted secret in the infrastructure repository.
    6. Modify Kubernetes deployment to inject a secret into the microservice.

Part 7: Recap

  1. Core concepts: Infra as code, Git as the source of truth, pull model, converging changes
  2. Core flow: declare infrastructure, commit it, pull request for review, merge to apply
  3. Next steps
    1. Automated promotion (If a deployment to a staging environment succeeds, then trigger a deployment to production.)
    2. Observability (microservices that export metrics, logging aggregator, and monitoring)

Bonus exercises

  1. Replace manual steps (push Docker container, build application code) with CI, such as GitHub actions.
  2. Introduce templating (Jsonnet, Helm) to foster reuse of Kubernetes resources.
    1. Exercise: Parameterize deployment so that port can be defined as configuration. Deploy a second copy of the same service with a different name, running on a different port.
  3. Install more advanced resources in the cluster using the same mechanism, such as an ingress controller.

Azure DevOps for Teams

Posted on January 27, 2021 by -

Part 1: Getting Started

  1. Introductions
  2. Course Goal
  3. Team Agreement

Part 2: Azure DevOps Overview

  1. Hierarchy
  2. List
  3. Board
  4. Backlog
  5. Work items

Part 3: Agile & Scrum Review

  1. Manifesto
  2. Principle
  3. Scrum Overview

Part 4: Accessing Azure DevOps

  1. Login
  2. Navigation

Part 5: Managing Iterations

  1. Configure the time box iteration
  2. Setting interaction goal
  3. Configure Team Capacity

Part 6: Backlog Hierarchy

  1. Product backlog
  2. Attributes
  3. Epics, Feature, Stories
  4. Managing Work Item
  5. Adding Stories
  6. Link Epics to Feature to Stories to Tasks
  7. Prioritization guide line
  8. Adding Priority
  9. Estimating Guidelines
  10. Add Estimates
  11. Task Breakdown
  12. Adding Task
  13. Adding PBI’s to Iterations
  14. Blocking Tasks
  15. Kanban Overview

Part 7: Queries

  1. Creating Queries
  2. Running Queries

Part 8: Wikis

  1. Creating
  2. Editing

Part 9: Dashboards

  1. Configure Widgets
  2. Creating the Dashboard

Managing AWS Infrastructure with Terraform

Posted on December 1, 2020 by -

Part 1: Infrastructure as Code

In this section, we will introduce the benefits that Infrastructure as Code (IaC) can bring to organizations and how IaC fits within modern DevOps best practices.

  • Motivation for Infrastructure as Code
  • Applying Infrastructure as Code in DevOps
  • Infrastructure as Code principles and best practices
  • Benefits of Infrastructure as Code
  • The case for Terraform

Part 2: Terraform Overview

This section provides an overview of Terraform concepts and vocabulary and instructs how Terraform manages infrastructure configuration in cloud environments.

  • Terraform architecture
  • Terraform configuration language overview
  • Terraform CLI
  • The lifecycle of a configuration
  • Managing configuration state

Hands-on Labs:

  • Using the Terraform CLI
  • Setting up a Terraform project

Part 3: AWS Resources

In this section, participants will get hands-on practice using Terraform to create a simple application environment in AWS and learn the essential constructs in Terraform for defining resources.

  • Resource types
  • Best practices in declaring resources
  • Network resources (VPC, subnet, security group)
  • Compute resources (virtual machine)
  • Storage resources (database)
  • Local values in a configuration
  • Augmenting a configuration with data sources

Hands-on Labs:

  • Creating a VPC and subnets
  • Adding a virtual machine into your VPC
  • Adding a database to your VPC
  • Using locals for replicated values
  • Using a data source to read external configuration

Part 4: Terraform Programming

This section introduces programming constructs within Terraform that enable you to add more control and flexibility in defining resources.

  • Data structures (primitives, maps, lists, objects, etc.)
  • Types of expressions to set values
  • Creating multiples of a resource
  • Dynamic blocks
  • Parameterizing a configuration with variables
  • Outputs from a configuration
  • Functions
  • Handling errors

Hands-on Labs:

  • Using variables in a configuration
  • Getting outputs from a configuration
  • Creating a re-sizable cluster of virtual machines
  • Creating multiple resources through iteration loops
  • Leveraging functions in your code

Part 5: Modules

This section shows how modules can be used to create reusable components in Terraform and teaches best practices in organizing Terraform code.

  • Purpose of modules
  • Module structure and code organization
  • Invoking modules
  • Module sources and versioning
  • Nested modules
  • Publishing modules

Hands-on Labs:

  • Using an external module in your configuration
  • Refactoring your code to implement a module

Part 6: Wrapping Up

This section wraps up the course with reviews to reinforce what you have learned.

  • Reference material to learn more
  • Course review
  • Next steps

Mastering DAX for Microsoft Power BI

Posted on November 5, 2020 by -

Part 1: Introduction to DAX

  1. What is DAX?
  2. Why use DAX with Power BI
  3. Calculated Columns vs Measures
  4. Types of Functions
    1. Logical Functions
    2. Table manipulation functions
    3. Date and time functions
    4. Filter functions
    5. Financial functions
    6. Math and Trig functions 
    7. Parent and Child functions
    8. Relationship functions 
    9. Statistical functions
    10. Text functions
    11. Time intelligence functions

Part 2: Logical functions

  1. TRUE
  2. FALSE
  3. IF
  4. IFERROR
  5. AND
  6. OR
  7. SWITCH
  8. COALESCE

Part 3: Tables

  1. Tables Overview
  2. Filtering Tables
    1. FILTERS
    2. TOPN
  3. Summarizing Tables
    1. SUMMARIZE
    2. SUMMARIZECOLUMNS
    3. ROLLUP
    4. GROUPBY
  4. Generating Tables
  5. Distinct Values
    1. DISTINCT column
    2. DISTINCT table
  6. Joining Tables
    1. CROSSJOIN
    2. NATURALINNERJOIN
    3. NATURALLEFTOUTERJOIN
  7. Adding Values
    1. Columns
    2. Missing items
  8. Table Constructor

Part 4: Date and Time Functions

  1. Date and Time Functions Overviews
  2. Units of Time
  3. Creating a Calendar
    1. CALENDAR
    2. CALENDARAUTO
  4. Dates
  5. TODAY
  6. NOW
  7. TIME
  8. TIMEVALUE

Part 5: Filter Functions

  1. Filter Functions Overview
  2. Filtering Tables
    1. FILTER
    2. REMOVEFILTERS
    3. ALL (ALL, ALLCROSSFILTERED, ALLEXCEPT, ALLNOBLANKROW, & ALLSELECTED)
    4. CALCULATETABLE
    5. KEEPFILTERS
  3. CALCULATE
  4. LOOKUPVALUE
  5. SELECTEDVALUE

Part 6: Financial functions

  1. Accrued Interest
    1. ACCRINT
    2. ACCRINTM
  2. Depreciation
    1. DB
    2. DDB

Part 7: Relationships Functions

  1. CROSSFILTERS
  2. RELATED
  3. RELATEDTABLE
  4. USERELATIONSHIP
  5. Parent and Child Functions
    1. PATH
    2. PATHCONTAINS
    3. PATHITEM
    4. PATHITEMREVERSE

Part 8: Text functions

  1. FIND
  2. SEARCH
  3. REPLACE
  4. FORMAT
  5. LOWER
  6. UPPER
  7. RIGHT
  8. LEFT
  9. COMBINEVALUES
  10. CONCATENATE
  11. CONCATENATEX
  12. EXACT
  13. FIXED
  14. LEN
  15. MID
  16. SUBSTITUTE
  17. TRIM
  18. VALUE

Part 9: Statistical functions

  1. Central Tendencies
    1. Averages
    2. Means
    3. Geo means
  2. Counting
    1. Counting and COUNTX
    2. Blanks, and rows
    3. Distinct count: distinct, approximate, no blank
  3. Min/Max
    1. MAX, MAXA and MAXX
    2. MIN, MINA and MINX
  4. Sample
  5. Distributions
    1. Normal
    2. Exponential
    3. Beta
    4. Poisson
  6. Inverse
  7. Percentiles
  8. Ranking
  9. Standard Deviation
  10. Variance
    1. VAR.P and VARX.P
    2. VAR.S and VARS.P

Deploying and Automating Infrastructure at Scale

Posted on October 27, 2020 by -

Part 1 – Infrastructure Platform: AWS Cloud

  1. Installing and using the AWS CLI (Command Line Interface)
  2. AWS Networking
  3. VPC’s (Virtual Private Clouds)
  4. Subnets
  5. Internet Gateways
  6. Route Tables
  7. Route Table Associations
  8. Creating AWS Networking Components
  9. Launching VMs in AWS Cloud

Part 2 – Git: Source Control Management: GitHub

  1. This course doesn’t teach the basics of git. Git experience is assumed (see the ‘DevOps Pipeline’ course if your team needs basic git knowledge)

Part 3 – Infrastructure Deployment: Terraform

  1. Intro to Terraform
  2. Creating cloud buckets for storage
  3. Separating code: Multiple Terraform configuration files
  4. Storing state remotely
  5. Git branching
  6. Displaying resource outputs
  7. Creating cloud networking components with Terraform
  8. Configuring cloud Security groups
  9. Using SSH Public/Private Keys with Terraform
  10. Launching and Destroying cloud VM instances with Terraform
  11. Creating reusable code with modules
  12. Using Terraform variables

Part 4 – Configuration Management: Terraform with Ansible

  1. Ansible Provisioners in Terraform
  2. Integrating Terraform-managed instances with Ansible Control Nodes
  3. Launching multi-tiered architectures (web servers and load balancers) with Terraform and Ansible

Part 5 – Notifications: Slack

  1. Integrating CI/CD with Slack
  2. Using Slack for CI/CD approvals and notifications

Part 6 – Containerization: Docker

  1. Purpose and use case for Docker
  2. Docker Hub
  3. Basic Docker commands
  4. Docker Networking
  5. Launching and debugging NGINX containers
  6. Mounting Volumes to containers
  7. Docker mount points: Multiple containers, one shared code location
  8. Launching Docker hosts and Docker containers automatically
  9. Port mapping with containers
  10. Launching multi-tiered architectures (web servers and load balancers): an automated approach
  11. Customizing containers with Docker Hub and Dockerfiles
  12. Reducing infrastructure bloat: Buster-Slim Docker containers

Part 7 – Managed OS: Linux Only

  1. Management of Linux Servers only

Part 8 – Container Management: Kubernetes (Optional)

  1. Kubernetes (K8S) overview and use case
  2. K8S architecture
  3. Installation and configuration
  4. Master and node server components
  5. Creating K8S load-balanced clusters
  6. Deploying Apps with K8S
  7. Scaling Apps
  8. K8S monitoring and App repair
  9. Updating Apps with K8S

Building Microsoft Power BI Dashboards

Posted on October 23, 2020 by -

Part 1: What is BI?

We’ll start out by covering business intelligence basics to lay the groundwork for an intelligent approach to reporting and visualizing data.

  • Business Intelligence Overview
  • Common Challenges
  • Benefits of Power BI

Part 2: Getting started with Power BI

Power BI is an extensive toolbox for working with and analyzing data. We’ll cover the fundamentals of the service, how Power BI’s features are organized, and immediately orient towards dashboards and visualization.

  • Overview & Pricing/Licensing
  • Components of Power BI
  • Building Blocks of Power BI
  • Quick Tour of Power BI Service

Part 3: Building simple reports

Reports are the first step in graphically communicating information related to your data. In this section of the class, you’ll learn to use and navigate the types of datasets you encounter every day, and how to use them to begin shaping meaningful communication.

  • Importing excel data
  • Using preexisting datasets
  • Creating visualizations
  • Using slicers

Part 4: Dashboards

In this section, we’ll cover how to create and use dashboards for common needs. By the end of this section, you’ll understand what’s realistic to expect from your PowerBI dashboards and how to set them up, share them, and produce valuable insights with your team quickly.

  • Dashboard expectations vs. features
  • Using KPI
  • Create and Configure a Dashboard
  • Shared Dashboards with your Organization
  • Pinning visuals

Part 5: Exploring data

In this final section of class, we’ll get a bit more granular about navigating, analyzing and communicating about your data. By the time we conclude, you’ll be ready to start applying what you’ve learned in your own real-world situations. 

  • Use Quick Insights
  • Display Visuals and Tiles Full-Screen
  • Edit Tile Details
  • Get More Space on Your Dashboard
  • Ask Questions of your Data with Natural Language
  • Advanced Navigation

Implementing Azure DevOps Pipelines

Posted on October 17, 2020 by -

Part 1: Course Introduction

  1. Azure Repos-Chef-Azure Pipelines: A DevOps Pipeline
  2. Course Purpose
  3. Agenda
  4. Introductions
  5. Lab Environments

Part 2: Technology Overview

  1. Git – Source Control Management
  2. Chef – Configuration Management
  3. Azure Pipelines – Continuous Integration
  4. An End-To-End CI/CD (Continuous Integration/Continuous Deployment) Pipeline

Part 3: Git/Azure Repos – Source Control Management

  1. Git purpose and Workflow
  2. Git configuration
  3. Getting help with git
  4. Basic git commands
  5. Remote, status, add, commit, push, log, diff
  6. Creating and checking out branches
  7. Creating a repository in Azure Repo
  8. Accessing a private repository with SSH keys
  9. Pull requests
  10. Merging and deleting branches

Part 4: Chef – Configuration Management

  1. Chef purpose and use cases
  2. Chef basics: Resources, recipes, and cookbooks
  3. Chef policy files
  4. Integration testing with Inspec and Test kitchen
  5. Chef variables: Attributes and Ohai
  6. Dynamic file creation with templates
  7. Using Chef Supermarket and community cookbooks
  8. Wrapper cookbooks
  9. Automating infrastructure with Chef Search
  10. Centralized management with Chef Infra Server
  11. Automating Chef convergence
  12. Managing nodes with policy groups

Part 5: Azure Pipelines

  1. CI/CD = Continuous Integration / Continuous Deployment
  2. Purpose
  3. Projects
  4. Jobs
  5. YAML scripting – CI/CD as Code
  6. Managing credentials and secret files
  7. Integrating with Source Control Management: Azure Repos
  8. Triggers: Scheduled Polling and Webhooks
  9. Automated cookbook linting: Foodcritic and Cookstyle
  10. Automated cookbook testing with Test Kitchen
  11. Azure Pipelines Integration with Chef Server
  12. Creating Separate Build and Release Pipelines
  13. Continuous Deployment of Chef cookbooks with Azure Pipelines

Implementing a CI/CD Pipeline

Posted on October 17, 2020 by -

Part 1: Technology Overview

  1. Git – Source Control Management
  2. Ansible – Configuration Management
  3. Jenkins – Continuous Integration/Continuous Deployment

Part 2: Git – Source Control Management

  1. Purpose overview and use cases
  2. Git workflow
  3. Configuring git on your local machine
  4. Getting help with Git
  5. Local vs. Global vs. System configurations
  6. Basic Git Commands
  7. Creating local git repositories
  8. Branching and merging
  9. Using remote repositories
  10. Pushing code to Github using public and private SSH keys

Part 3: Ansible – Configuration Management

  1. Ansible purpose and use cases
  2. Architecture and call flow
  3. Ansible installation, configuration, and validation
  4. Control nodes and managed nodes
  5. Ansible managed hosts
  6. Host inventory; hosts and groups
  7. Repeatable code: Playbooks
  8. Introduction to YAML
  9. Modularizing code: Roles
  10. Ansible variables
  11. Dynamic configuration with facts
  12. Finding errors: Ansible unit testing
  13. Ensuring code quality: Ansible integration testing

Part 4: Jenkins – Continuous Integration / Continuous Deployment

  1. CI/CD overview, use cases and history
  2. Plugin architecture
  3. Initializing a Jenkins server
  4. Projects and jobs
  5. Freestyle jobs
  6. CI/CD as Code: Pipeline projects
  7. Declarative vs. scripted pipelines
  8. Jenkins Environment variables and parameters
  9. Distributed architecture: Master and agent nodes
  10. Views and Folders
  11. Managing credentials and secrets
  12. Integrating with git Source Control Management
  13. Triggers: Webhooks and Polling
  14. Notifications: Instant messaging and SMTP Email
  15. Approval inputs
  16. Testing Ansible playbooks in Jenkins
  17. Multibranch Pipelines: Reading entire repositories
  18. Conditional Logic
  19. Deploying Ansible playbooks with Jenkins: An automated end-to-end deployment pipeline