Course Taxonomy: DevOps

Certified SAFe® DevOps Practitioner (SDP)

  1. Introducing DevOps
  2. Mapping your Continuous Delivery Pipeline
  3. Gaining alignment with Continuous Exploration
  4. Building quality with Continuous Integration
  5. Reducing time-to-market with Continuous Deployment
  6. Delivering Business Value with Release on Demand
  7. Taking action

Implementing Site Reliability Engineering

Part 1 – Introduction

1. Introduction

2. The Production Environment at Google, From the Viewpoint of an SRE

3. Exercise: Mapping Your Production Environment

Part 2 – Principles

1. Embracing Risk

  • Managing Risk
  • Measuring Service Risk
  • Risk Tolerance of Services
  • Motivation for Error Budgets

2. Service-Level Objectives

  • Service Level Terminology
  • Indicators in Practice
  • Objectives in Practice
  • Agreements in Practice
  • Exercise: Setting Service-Level Objectives

3. Eliminating Toil

  • What Is Toil?
  • Why Less Toil is Better
  • What Qualifies as Engineering?
  • Is Toil Always Bad?

4. Monitoring Distributed Systems

  • Definitions
  • Why Monitor?
  • Setting Reasonable Expectations
  • Symptoms Versus Causes
  • Black Box Versus White Box
  • The Four Golden Signals
  • Worrying About Your Tail
  • Choosing an Appropriate Resolution for Measurements
  • As Simple as Possible, No Simpler
  • Tying These Principles Together
  • Monitoring for the Long Term

5. The Evolution of Automation at Google

  • The Value of Automation
  • The Value for Google SRE
  • Use Cases for Automation
  • Automate Yourself Out of a Job
  • Soothing the Pain: Applying Automation to Cluster Turnups
  • Borg: Birth of the Warehouse-Scale Computer
  • Reliability is the Fundamental Feature

6. Release Engineering

  • The Role of a Release Engineer
  • Philosophy
  • Continuous Build and Deployment
  • Configuration Management

7. Simplicity

  • System Stability Versus Agility
  • The Virtue of Boring
  • I Won't Give Up My Code!
  • The "Negative Lines of Code" Metric
  • Minimal APIs
  • Modularity
  • Release Simplicity

Part 3 – Practices

1. Practical Alerting

  • Time-Series Monitoring Outside of Google
  • Instrumentation of Applications
  • Exporting Variables
  • Collection of Exported Data
  • Storage in the Time-Series Arena
  • Rule Evaluation
  • Alerting
  • Sharding the Monitoring Topology
  • Black-Box Monitoring
  • Maintaining the Configuration

2. Being On-Call

  • The Life of an On-Call Engineer
  • Balanced On-Call
  • Feeling Safe
  • Avoiding Inappropriate Operational Load

3. Effective Troubleshooting

  • Theory
  • In Practice
  • The Magic of Negative Results
  • Making Troubleshooting Easier
  • Exercise: Distributed System Troubleshooting

4. Emergency Response

  • What to Do When Systems Break
  • Test-Induced Emergency
  • Challenge-Induced Emergency
  • Process-Induced Emergency
  • Don't Repeat the Past—Learn From It

5. Managing Incidents

  • Unmanaged Incidents
  • Managed Incidents
  • When to Declare an Incident
  • Elements of Incident Management Process

6. Postmortem Culture: Learning from Failure

  • Google's Postmortem Philosophy
  • Collaborate and Share Knowledge
  • Introducing a Postmortem Culture
  • Exercise: Blameless Postmortem

7. Tracking Outages

  • Escalator
  • Outalator

8. Testing for Reliability

  • Types of Software Testing
  • Creating a Test and Build Environment
  • Testing at Scale

9. Software Engineering in SRE

  • Why is Software Engineering Within SRE Important?
  • Auxon Case Study
  • Intent-Based Capacity Planning
  • Fostering Software Engineering in SRE

10. Load Balancing at the Front End

  • Load Balancing Using DNS
  • Load Balancing at the Virtual IP Address

11. Load Balancing in the Datacenter

  • Identifying Bad Tasks: Flow Control and Lame Ducks
  • Limiting the Connections Pool with Subsetting
  • Load-Balancing Policies

12. Handling Overload

  • The Pitfalls of "Queries Per Second"
  • Per-Customer Limits
  • Client-Side Throttling
  • Criticality
  • Utilization Signals
  • Handling Overload Errors
  • Load from Connections

13. Addressing Cascading Failures

  • Causes of Cascading Failures and Designing to Avoid Them
  • Preventing Server Overload
  • Slow Startup and Cold Caching
  • Triggering Conditions for Cascading Failures
  • Testing for Cascading Failures
  • Immediate Steps to Address Cascading Failures

14. Managing Critical State: Distributed Consensus for Reliability

  • Motivating the Use of Consensus: Distributed Systems Coordination Failure
  • How Distributed Consensus Works
  • System Architecture Patterns for Distributed Consensus
  • Distributed Consensus Performance
  • Deploying Distributed Consensus-Based Systems

15. Distributed Periodic Scheduling with Cron

  • Cron Jobs and Idempotency
  • Cron at Large Scale
  • Building Cron at Google

16. Data Processing Pipelines

  • Origin of the Pipeline Design Pattern
  • Initial Effect of Big Data on the Simple Pipeline Pattern
  • Challenges with the Periodic Pipeline Pattern
  • Trouble Caused by Uneven Work Distribution
  • Drawbacks of Periodic Pipelines in Distributed Environments
  • Introduction to Google Workflow
  • Stages of Execution in Workflow
  • Ensuring Business Continuity

17. Data Integrity: What You Read Is What You Wrote

  • Data Integrity's Strict Requirements
  • Google SRE Objectives in Maintaining Data Integrity and Availability
  • How Google SRE Faces the Challenges of Data Integrity
  • 1T Versus 1E: Not "Just" a Bigger Backup
  • Knowing that Data Recovery Will Work
  • Case Studies
  • General Principles of SRE as Applied to Data Integrity

18. Reliable Product Launches at Scale

  • Launch Coordination Engineering
  • Setting Up a Launch Process
  • Developing a Launch Checklist
  • Selected Techniques for Reliable Launches
  • Development of LCE
  • Exercise: Develop a Production Readiness Review

Part 4 – Management

1. Accelerating SREs to On-Call and Beyond

  • You've Hired Your Next SRE, Now What?
  • Initial Learning Experiences: The Case for Structure Over Chaos
  • Creating Stellar Reverse Engineers and Improvisational Thinkers
  • Reverse Engineering a Production Service
  • Five Practices for Aspiring On-Callers
  • On-Call and Beyond: Rites of Passage and Practicing Continuing Education

2. Dealing with Interrupts

  • Managing Operational Load
  • Factors in Determining How Interrupts Are Handled
  • Imperfect Machines

3. Embedding an SRE to Recover from Operational Overload

  • Phase 1: Learn the Service and Get Context
  • Phase 2: Sharing Context
  • Phase 3: Driving Change

4. Communication and Collaboration in SRE

  • Communications: Production Meetings
  • Collaboration Within SRE
  • Case Study: Viceroy
  • Collaboration Outside SRE
  • Case Study: Migrating DFP to F1

5. The Evolving SRE Engagement Model

  • SRE Engagement: What, How, and Why
  • The PRR Model
  • The SRE Engagement Model
  • Production Readiness Reviews: Simple PRR Model
  • Evolving the Simple PRR Model: Early Engagement
  • Evolving Services Development: Frameworks and SRE Platform

Part 5 – Conclusions

1. Lessons Learned From Other Industries

2. Conclusion

Advanced Kubernetes Boot Camp

Part 1: Core Concepts

We’ll go deep into different terms of Kubernetes to understand what it takes to build and run scalable systems in production. There are design patterns that you can implement in Kubernetes to extend an existing application without having to change the source code, like a sidecar pattern.

  1. Kubernetes architecture
  2. Imperative commands and descriptive manifests
  3. Pods, deployments, services, namespaces, DaemonSets
  4. Exercise: Working with Pods
  5. Exercise: Working with ReplicaSet
  6. Exercise: Working with Deployments
  7. Exercise: Working with Services
  8. Multi-containers
  9. Init containers
  10. Exercise: Working with StatefulSet
  11. Working with multiple clusters (kubeconfig)
  12. Kubernetes design patterns

Part 2: Networking in Kubernetes

Understanding how networking works in Kubernetes is important because it will help you to configure networking patterns like service discovery for a microservices architecture. But another concept that is taking more relevance are service meshes. We’ll explore what a service mesh is, and we’ll practice using one of the most popular ones: Istio.

  1. Ingress networking
  2. Exercise: Working with Ingress
  3. Networking policies
  4. Exercise: Working with Networking Policies
  5. What’s a service mesh?
  6. Introduction to Istio
  7. Observability with Istio
  8. Networking security with Istio
  9. Canary releases with Istio
  10. Exercise: Working with Istio

Part 3: Creating Scalable and Fault-Tolerant Applications

Kubernetes has a lot of great features built in by implementing the controller pattern. But in many cases, our applications need to include small configurations to help Kubernetes make better decisions to support reliable applications. We’ll see what changes are needed in the applications, and then we’ll deploy and test a sample application.

  1. Working with configuration
  2. Exercise: Working with ConfigMaps
  3. Working with probes
  4. Exercise: Working with Probes
  5. Configuring requests and limits
  6. Taints and tolerations
  7. Exercise: Working with Taints and Tolerations
  8. Node selectors
  9. Configuring scaling policies
  10. Exercise: Configuring scaling policies

Part 4: Development Workflow in Kubernetes

Kubernetes doesn’t have to change the way developers build applications, but they might want to be involved or test in their local workstations when they’re done with their application changes. We’ll discuss some recommended practices and tools.

  1. Packaging and managing applications with Helm
  2. Exercise: Working with Helm
  3. Continuous delivery in Kubernetes
  4. Exercise: Continuous Delivery with Flux
  5. Logging and monitoring systems
  6. Troubleshooting application failures
  7. Exercise: Troubleshooting Applications
  8. Development Toolbox: State of the art

Part 5: Developing Stateful Services

Stateless services are great for certain use cases, but there are scenarios where an application needs to be able to store data permanently, or at least work with data that is not ephemeral. Databases are one example.

  1. Understanding persistent volumes
  2. Exercise: Working with PV and PVC
  3. Backup and restore in Kubernetes
  4. Exercise: Backup and restore with Velero
  5. Databases in Kubernetes

Part 6: Security Practices and Recommendations

Kubernetes is not secure by default, and there are many considerations that you need to be aware of if before exposing your applications to the public internet. Companies usually have existing security policies, so we’ll cover how these security practices apply in a Kubernetes ecosystem.

  1. Authentication and Authorization
  2. Integration with AWS and IAM
  3. Docker image and pods security
  4. Pod Security Context and Policies
  5. Secrets encryption using KMS
  6. Exercise: Security in Kubernetes

Part 7: Extending the Kubernetes API

There are times where we need to extend the Kubernetes API to operate systems more easily. Not everyone will need to build something to extend the Kubernetes API, but it’s very valuable to understand the what, when, and how of custom resource definitions and the operator pattern.

  1. Custom Resource Definition (CRD)
  2. Custom Controllers
  3. Operator Pattern
  4. Operator Framework
  5. Exercise: Creating an Operator

Part 8: What’s Next for Kubernetes?

We’ll discuss other topics related to Kubernetes that might not fit everyone’s use cases, but that as a Kubernetes user you might want to be aware of. For instance, we’ll talk a little bit about having federated clusters, hybrid workloads, and several important tools from the CNCF.

Managing Azure Infrastructure with Terraform

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.

  1. DevOps and GitOps
  2. Principles of Infrastructure as Code
  3. Applying Infrastructure as Code in DevOps
  4. Infrastructure as Code best practices
  5. Benefits of Infrastructure as Code
  6. 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.

  1. Terraform configuration language overview
  2. Terraform CLI
  3. The lifecycle of a configuration
  4. State storage – local versus remote
  5. Connecting to Azure

Hands-on Labs:

  • Setting up a Terraform project

Part 3: Azure Resources

In this section participants will be getting hands-on practice using Terraform to create a simple application environment in Azure, learning the essential constructs in Terraform for defining resources.

  1. Resource metadata and naming best practices
  2. Subscription and resource group
  3. Networking resources (VNet, subnet, network security group)
  4. Compute resources (virtual machine)
  5. Storage resources (storage account, file share, blob storage)
  6. Database resources (SQL database)
  7. Variables
  8. Outputs

Hands-on Labs:

  • Deploying a VNet
  • Adding a virtual machine into your VNet
  • Adding storage and a database
  • Including variables in your code
  • Using Terraform commands to validate and inspect your configuration

Part 4: Terraform Programming

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

  1. Control operations (count, loops, conditional, depends_on, etc.)
  2. Data structures (maps, lists, random_string, etc.)
  3. Data sources
  4. Functions (e.g., lookup, coalesce, join, merge, etc.)
  5. Variable validation
  6. Debugging Terraform

Hands-on Labs:

  • Managing multiple resources through count and loops
  • Using maps and lists in your code
  • Using functions in your code
  • Using Terraform CLI and state manipulation to debug your configuration

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.

  1. Purpose of modules
  2. Modules code file organization structure
  3. Module structure
  4. Module sources and versioning
  5. Nested modules
  6. Publishing modules

Hands-on Labs:

  • Refactoring your earlier lab code to a module
  • Using Azure modules (subscription, metadata, resource group, virtual network)

Part 6: Wrapping Up

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

  1. Reference material to learn more
  2. Course review
  3. Next steps

Cloud Strategy Boot Camp

Part 1: Fundamentals of Cloud Computing

  1. Tenets of Cloud Computing
    • What makes something “cloud”?
    • The five tenets
    • Why the five tenets are so difficult in practice
    • The cloud mindset
  2. Cloud Deployment Models
    • Types of providers
      • Public
      • Private
      • Hybrid
    • Combining providers
      • Single
      • Multi-cloud
    • Choosing among provider types
    • Using cloud providers securely
  3. Cloud Service Models
    • Infrastructure as a service (IaaS)
    • Platform as a service (PaaS)
    • Software as a service (SaaS)
    • Serverless
  4. Communicating Your Cloud Journey
    • Share your cloud strategy
    • Don’t ignore the people side of strategy success
    • Stay connected regularly and be available
    • Expect challenges and doubters
    • Celebrate your successes and share lessons learned
    • Exercise: Develop a communications plan

Part 2: Cloud Strategy Overview

  1. What Is Cloud Strategy?
    • What it is (and isn’t)
    • Relation to other strategies and plans
    • Once you have one, now what?
  2. From Business Vision to Cloud Strategy
    • Desired business outcomes
    • Potential benefits
    • Potential risks
    • The rise of bimodal IT
    • Business-specific factors
    • Exercise: Align benefits and risks with desired outcomes
  3. Cloud Strategy Council
    • What is it?
    • Why do you need one?
    • Who’s on it?
  4. Services Model
    • Consume
    • Build
    • Broker
    • Hybrid Management
    • Exercise: Develop sample services model
  5. Financial Models
    • How pricing works for cloud services
    • Is cloud cheaper?
    • CapEx vs. OpEx
  6. Principles
    • Why principles matter
    • Common cloud principles
    • How to choose yours
    • Exercise: Select cloud principles for sample case
  7. Workload Inventory
    • The hard work of preparation
    • Exercise: Complete a sample workload inventory
  8. Establish Governance Model
    • Importance of cloud governance
    • Layers of governance
      • Enterprise architecture
      • Technical architecture
      • Application architecture
      • Data architecture
    • Risk and compliance
      • Legal compliance
      • Industry compliance
      • Internal policies
    • Cloud center of excellence
  9. Staffing, Resource, and Training Impacts
    • Assessment of roles needed and impacted
    • Evaluate corporate staffing and resource policies
    • Exercise: Complete a sample training plan
  10. Exit Strategy
    • Why it’s critical to have one
    • Contracts
    • Data ownership and retention
    • Potential risks and issues

Part 3: Beginning Cloud Adoption

  1. Cloud Adoption Framework
    • Assess
    • Perform
    • Extend
    • Improve
  2. Assess Your Cloud Readiness
    • Initiating your adoption planning
    • Conducting cloud readiness assessments inventorying
    • Interpreting readiness results
    • Moving from assessment to action plan
    • Exercise: Complete a sample readiness assessment
  3. Cloud Migration Decision Framework: The 6Rs
    • Replace
    • Refactor
    • Rehost
    • Retain
    • Retire
    • Replatform
    • Exercise:Apply cloud migration decision framework to a sample case
  4. Select Your First Cloud Service
    • Prioritize candidate services
      • Select candidates for your first cloud service
      • Assess service criticality of each candidate
      • Assess risk and benefit of each candidate
      • Decide on the first cloud service
    • Architect selected cloud service
      • Cloud native
      • 12 factor app methodology
      • LIFESPAR
      • Exercise: Rearchitect sample architecture for cloud migration
    • Evaluate cost and return
      • Maximize your cloud value
        • Avoid surprise bills
        • Use demand forecasting effectively
        • Trade off space and time to save money
        • Hit your uptime targets without breaking the bank
      • Assess benefits of cloud service
        • Operational efficiencies or agility
        • Changes in staffing and skill sets
          • Operations
          • Development
          • Security
        • Expected cost savings from infrastructure
        • Determine costs of cloud services
        • Assessing impact on staff resources
      • Compute cloud service costs
        • Throughput
        • Compute time
        • Scalability
        • Resiliency
      • Exercise: Estimate cost for sample architecture for public cloud providers

Part 4: Extending and Improving Adoption

  1. Assess Hybrid Operating Challenges
    • Development and testing
      • Development toolchain
      • Debugging in the cloud
      • Testing
    • Operations
      • The rise of SRE
      • Moving administration up the stack
      • Aligning cloud service monitoring and on-premises monitoring
      • Survey of SRE vendors and tools
    • Security
      • Incident and event management
      • Auditing
      • Policy enforcement
      • Penetration testing
      • Threat assessment and modeling
      • Vulnerability management
    • Identity and access controls
      • The continuum of identity from on-premises to IDaaS
      • Understand the benefits and trade-offs of IAM protocols
      • Identity as the new edge
      • The hidden costs of identity in SaaS
      • Survey of cloud IAM vendors
    • Environment management
      • Moving from on-premises environments to cloud environments
      • Hybrid environment challenges
    • Configuration management
      • Impact of cloud service models on configuration
      • Storing secrets securely
      • Managing secrets over time
      • Monitoring for drift
      • Survey of configuration management vendors and tools
    • Deployment and release management
      • A new philosophy of release management
      • Separating deployment from release
      • Monitor and recover from failed deployments
      • Data management
        • Implement proper security controls
        • Plan a successful data migration effort
        • Establish audit and traceability
        • Analysis and reporting from the cloud
          • Business continuity and disaster recovery
            • Evaluate business continuity procedures
            • Evaluate disaster recovery procedures
  1. Improve Cloud Adoption Practices
    • Conduct regular retrospectives
    • Improve automation
    • Manage workloads
    • Refine governance, security, and risk processes
    • Train and develop staff
    • Monitor cloud consumption
    • Perform ongoing security and risk assessments

 Part 5: Wrap Up

  1. Our Cloud Strategy Journey
  2. What To Do Now
  3. Final Thoughts

DevSecOps Boot Camp

Part 1: DevOps, Security, and DevSecOps: Definitions

1. DevOps

2. Security

3. Risk

4. Culture

5. Agility

6. Testing

7. Continuous Integration

8. Continuous Delivery

Part 2: Where do we start with security?

1. Risk review

2. Policy

3. Roles

4. Compliance, regulatory and GRC

5. The Pipeline Model

6. Exercise A: Value Stream Mapping

Part 3: Security as a DevOps practice

1. Traditional vs. “DevOps” security

2. Tools vs. processes

3. Security, not compliance

4. Prioritizing testing for risk

5. Reducing source code footprint

6. Static analysis for secure code

7. Feature toggles for security

  • Toggle points
  • Toggle router
  • Toggle configuration

8. DevSecOps and technical debt management

Part 4: DevSecOps and “requirements”

1. Designing for security

2. Assessing risk appetite

3. Modeling threats

4. Product architecture

5. Use cases, antipatterns, and abuse cases

6. Dataflows and trust boundaries

7. Exercise B: Threat Modeling

Part 5: Secure development patterns

1. Secure code overview

2. OWASP review

3. Tools for automating OWASP

  • OWASP dependency checkers
  • OWASP Zap during regular functional tests

4. Developer guidelines & checklists

5. Tools to use

6. Coding Standards (top 5 languages)

7. Common pitfalls

8. Identifying Unsafe Code

Part 6: Security Testing in the Pipeline

1. Testing before commit

2. Scanning for secrets

3. Hook examples

4. Application security testing

  • Static
  • Dynamic

5. Testing dependencies

6. How to treat manual testing

7. Performance Testing

  • Testing for load
  • Testing for stress
  • Soak tests
  • Spike testing

8. Testing in parallel

9. Staging

10. Mutation testing and tools for performing it

11. User role testing

Part 7: Identity and Access Management (IAM)

1. IAM overview

2. Identity profiles

3. Using IAM for automation

4. IAM practices in the cloud

5. IAM as an application building block

6. IAM antipatterns

7. Guided discussion: IAM in a Microservices use case

Part 8: Deployment patterns for security

1. Canary candidates

2. Dark launches

3. Streamlining libraries and dependencies

4. Keeping packages up to date

5. Keeping deploys repeatable and reliable

6. OpenSCAP for scanning baselines before and after deployments

7. Scanning web server configuration

8. Database exploitation through applications

9. Infrastructure scanning

  • OpenVAS
  • NMAP

10. Scanning web applications

  • W3AF
  • Wapiti

Part 9: DevSecOps and Operations

1. Where does Ops security begin and end?

2. Infrastructure as Secure Code

3. Incident response planning and emergency drills

4. Release Archives

5. OS Protections:

  • Address Space Layout Randomization
  • Non-Executable Stacks
  • W^X
  • Data Execution Prevention
  • SELinux

7. Monitoring, logging and intelligent alerts

  • Splunk mini-tour: A transformative tool for analyzing machine data, operational risk, and application health

8. Log management

9. Penetration Testing

10. Exercise C: Profiling a DevSecOps Hybrid model

Part 10: Policy, Governance, and Audit

1. GRC review

2. Coding for compliance

3. DevOps and the “segregation of duties”

4. Tooling example: Chef InSpec

5. Change management and policy

6. Exercise D: Automated vs. Manual, to comply with Audit requirements

Part 11: Change management and DevSecOps

1. Three types of “change”

2. When and why to use CAB boards

3. Peer review vs. change management

4. Automating change management

ITIL in 2020

Part 12: Measurement and metrics

1. The core toolkit of metrics

2. The best way to institute alerts

3. Managing alerts

4. Proactive vs. reactive metrics

5. Measurement antipatterns

Part 13: More advice on the cultural factors

1. Security fails and breakdowns

2. Incentive, fear, and reward

3. Getting outside IT

4. How to shift left

5. Building security in

6. Cost and the business case for proactive security

7. Overcoming conventions of the past

8. Bridging silos – why and how

9. Exercise E: Rearranging incentives

Part 14: Putting it all together

1. Class recap and final questions

2. What will you do differently when you return to work?

Docker Containerization Boot Camp

Students should bring laptops to class. This 3-day Docker training workshop is conducted as a continuous hands-on lab. From the initial install to the multi-container application stack, you will learn Docker through real-world practice.

Part 1: Introduction

  1. What can you use Docker for?
  2. A logical segregation of duties
  3. The relationship between Docker and SOA
  4. How Docker fits into the development lifecycle
  5. How Docker ensures consistency from development through UAT and staging, and on to production
  6. Example use cases of Docker in the real world

Part 2: The components of Docker

  1. Underlying technology
  2. Docker client and server
  3. Filesystem images
  4. Registries
  5. Containers
  6. Networking

Part 3: Getting set up to start using Docker

  1. Getting set up on Windows
  2. Getting set up on the Mac
  3. Trying out our first container
  4. Getting set up for production on Linux
  5. Tweaking your production environment for best performance
  6. User interfaces for Docker management

Part 4: Container management

  1. Container naming
  2. Starting and stopping containers
  3. Attaching to a container
  4. Seeing what is happening in a container
  5. Running a process inside a container
  6. Daemonizing a container
  7. Automatic container restarts
  8. Deleting containers when we are finished with them

Part 5: Docker images and repositories

  1. Docker images explained
  2. How Docker images work
  3. Getting a list of images
  4. Searching for images on a repository
  5. Pulling an image
  6. Creating our own image
  7. Specify an image in a Dockerfile
  8. Building Dockerfile images
  9. Using the build cache for templating
  10. Viewing the image we have created
  11. Launching a container using our new image

Part 6: Registries

  1. What is the Docker hub?
  2. Pushing images to the Docker hub
  3. Running your own internal Docker registry
  4. Testing the internal registry

Part 7: A simple use case

  1. A single container static website
  2. Setting up a container running Nginx
  3. Launching our static site
  4. Updating our static site from git or bitbucket

Part 8: Continuous integration with Docker

  1. How Docker enables and supports CI
  2. Getting set up for Jenkins and Docker
  3. A basic Jenkins job
  4. Multi-configuration jobs
  5. Drone
  6. Shippable

Part 9: A more complex use case: Multi container application stacks

  1. A container for our NodeJS application
  2. A base image for our Redis containers
  3. Creating our Redis back-end cluster
  4. Capturing logs
  5. Managing containers

Part 10: Docker orchestration and service discovery

  1. Getting set up with Fig
  2. Configuring the fig.yml file
  3. How to use Fig
  4. Console
  5. Running a Console cluster

Part 11: Integrating with configuration management

  1. Managing your Docker hosts with Chef / Puppet / Ansible
  2. Building containers using configuration management tools
  3. Managing running containers with configuration management

Part 12: Docker and DevOps

  1. Enabling collaboration with Docker
  2. Using Docker to streamline workflow
  3. Using Docker's version control capabilities to enable experimentation and learning
  4. Docker's role in the overall IT value chain
  5. Creating value and quality with Docker
  6. Enabling smoother flow of work

Part 13: Course conclusion, open discussion, and Q&A

  1. Going back to work with a plan
  2. What was not covered in this class
  3. Q&A with the instructor
  4. Goodbyes

DevOps Implementation Boot Camp (ICP-FDO)

Part 1: Introduction

1.      DevOps Defined

  • DevOps (Then and Now)
  • CI/CD
  • Infrastructure as Code
  • BizDevOps
  • DevSecOps
  • AIOps
  • DataOps

2.     High-Performance IT Organizations

  • Elite Performers
  • Use of the Cloud
  • Work-Life Balance
  • Optimized Change Review

3.     Origins and History of DevOps

  • The Quality Movement and W Edwards Deming
  • The Lean Movement and the Toyota Production System
  • The Agile Movement – Mindset, Value, Principles & Practices
  • The Continuous Delivery Movement

4.     Argument for DevOps

  • Business Value of DevOps
  • Net Effect of DevOps
  • Exercise: Argue for the value of DevOps in your organization

Part 2: Maturing a DevOps Practice in the Enterprise

1.      CALMS – The 5 DevOps Principles

2.     The 5 Cultural Challenges

3.     5 Cultural Dimensions

4.     Value Stream Mapping

  • Value Stream Definition and Examples
  • Exercise: Choose and Map a Case Study Value Stream
  • Analyze: Value Stream Lead Time, Quality, Involvement
  • Exercise: Analyze a Value Stream

Part 3: Your DevOps Journy – Optimize Flow

1.      Principles of Flow

  • 6 Principles of Flow from the DevOps Handbook
  • 8 Principles of Continuous Delivery from the Continuous Delivery book
  • Exercise: Apply Principles to your Case Study Value Stream

2.     Infrastructure as Code

3.     Infrastructure & Application Configuration Management

  • Configuration Management Tools
  • Exercise: Configuration Management in your Case Study Value Stream

4.     Deployment Pipeline

  • Deployment Pipeline Stages and Tools
  • Deployment Orchestration Tools
  • Deployment Pipeline: Everything in Version Control
  • Exercise: Deployment Pipeline in your Case Study Value Stream

5.     DevOps Quality Management

  • Quality Foundations
  • Quality Principles
  • Quality Practices
  • Test Automation Architecture
  • Test Automation Pyramid
  • Strategies for Managing Test Data
  • Code Analysis Tools
  • Automated Testing Tools
  • Exercise: DevOps Quality Management in your Case Study Value Stream

6.     CI/CD

  • Continuous Integration
  • Continuous Delivery
  • Exercise: CI/CD in your Case Study Value Stream

7.     Database Continuous Integration (DBCI)

  • Exercise: DBCI in your Case Study Value Stream

8.     Application Management Strategies

9.     Application Architecture – SOA, Microservices, Strangler Pattern

10.  Infrastructure Architecture – Virtualization & The Cloud

11.    Containerization

12.  Exercise: Optimize Flow in Your Case Study Value Stream

Part 4: Your DevOps Journey – Amplify Feedback

1.      Objective & Principles of Feedback

2.     Telemetry Definitions & Concepts

  • Telemetry Principles
  • Exercise: Telemetry Principles in your Case Study Value Stream
  • Integrating Security into Production Telemetry
  • Telemetry Layers & Levels
  • Ensuring Effective Alerts
  • System Monitoring, Log Agregation, and Alerting Tools
  • DevOps Metrics

3.     Advanced uses of Telemetry

  • Using Telemetry to Anticipate Problems
  • Feedback for Safe Deployment of Code
  • Developers Follow Their Apps Downstream
  • Hypothesis-Driven Development and A/B Testing
  • Exercise: Telemetry in your Case Study Value Stream

4.     Change Review and Coordination

5.     Exercise: Amplify Feedback in Your Case Study Value Stream

Part 5: Your DevOps Journey – Continual Learning & Experimentation

1.      Learning Culture

  • Blameless Postmortems
  • Responses to Failure
  • Blameless Postmortems

2.     Knowledge Sharing

3.     Innovation Culture

  • Institutionalize the Improvement of Daily Work
  • Encouraging Experimentation
  • Holding Learning and Improvement Events (Hackathons, Kaizen Blitzes, Rehearsing Large-Scale Failures, Fault Injection)

4.     Role of Leadership

5.     Exercise: Learning & Innovation Culture in your organization

Part 6: Planning Your DevOps Journey

1.      Cultural challenges

2.     Organizational challenges

3.     Transformation Patterns You Can Follow

  • Lean Startup Teams
  • Collaboration Tools
  • Automate Everything You Can
  • Reserve Time for Improvement

4.     Planning DevOps Transformation

5. Exercise: Your DevOps Action Plan

Chef Foundations – Official Chef Training

Part 1: Using Chef resources – the building blocks

Part 2 : Building Chef recipes and cookbooks

Part 3: Introduction to testing cookbooks with Test Kitchen

Part 4: Collecting details about the system via Ohai

Part 5: Attributes – writing dynamic code

Part 6: Managing data with templates

Part 7: Advanced templating – passing in variables

Part 8: Storing your code in a repo – an introduction to Git

Part 9: Workstation setup

Part 10: Centralizing management with Chef Server

Part 11: Using Community Cookbooks

Part 12: Automating chef-client runs

Part 13: Managing a multi-node infrastructure

Part 14: Simplification and scalability through Roles

Part 15: Power automation – invoking Chef Search

Part 16: Staging versus Production – Environments

Part 17: Using Databags to create user accounts on servers

Introduction to DevOps

Part 1: Introduction        

  1. DevOps Defined
  2. High-Performance IT Organizations
  3. Core Chronic Conflict
  4. Exercise: Pain Points
  5. Business Value of DevOps
  6. Where DevOps Came From
    1. W Edwards Deming & Total Quality Management
    2. The Lean Movement & Toyota Production System
    3. The Agile Development & Infrastructure Movements
    4. Exercise: Agile Infrastructure
    5. The Continuous Delivery Movement
  7. IT Service management & DevOps
  8. End Goals of DevOps & CALMS

Part 2: Maturing a DevOps Practice in the Enterprise       

  1. DevOps & Organizational Culture
  2. Two Patterns You Can Follow
  3. The Involvement Principle
    1. Information Security Principles
  4. Exercise: The Involvement Principle
  5. Scaling DevOps in the Enterprise

Part 3: The DevOps Journey – The Three Ways

The First Way: Optimize Flow

  1. Principles of Flow
  2. Infrastructure As Code
  3. Infrastructure Configuration Mgmt & Tools
  4. Deployment Pipeline & Tools
  5. Shared Version Control & Tools
  6. Build Quality In
  7. Containerization
  8. SOA and Microservices
  9. Exercise: Optimizing Flow

The Second Way: Amplify Feedback

  1. Principles of Feedback
  2. Telemetry Principles
  3. System Monitoring Tools
  4. Log Aggregation & Tools
  5. Use Telemetry to Anticipate Problems
  6. Feedback For Safe Deployment of Code
  7. Hypothesis-Driven Development
  8. Exercise: Amplifying Feedback

The Third Way: Continual Learning & Experimentation

  1. Learning Culture
  2. Innovation Culture
  3. Exercise: Learning & Innovation Culture

Part 4: Course Conclusion   

  1. Q & A