SRE Foundation Program Training

Introduction to Docker

• What is Docker?
• Why use Docker?
• Benefits of Docker
• Docker architecture
• Docker components

Building Docker images

• Dockerfiles
• Creating a Dockerfile
• Building a Docker image
• Pushing a Docker image to a registry

Running Docker containers

• Docker commands
• Starting, stopping, and managing Docker containers
• Networking Docker containers
• Data volumes in Docker

Docker best practices

• Docker security
• Docker troubleshooting
• Docker orchestration
• Resources for learning more about Docker

Introduction to Terraform

• What is Terraform?
• Why use Terraform?
• Terraform architecture
• Terraform configuration language
• Terraform modules

Terraform in practice

• How to install and configure Terraform
• How to write a Terraform configuration file
• How to use Terraform to provision infrastructure
• How to use Terraform to manage infrastructure changes
• Terraform best practices

Advanced Terraform topics

• Terraform providers
• Terraform data sources
• Terraform outputs
• Terraform modules in depth
• Terraform state

Terraform hands-on exercises

• Install and configure Terraform
• Write a Terraform configuration file to provision a simple infrastructure
• Use Terraform to manage infrastructure changes
• Use Terraform modules to provision complex infrastructure

Introduction to Ansible

• What is Ansible?
• Why use Ansible?
• Benefits of Ansible
• Ansible architecture
• Ansible components

Writing Ansible playbooks

• Ansible playbooks
• Playbook syntax
• Modules
• Variables
• Conditional statements and loops

Running Ansible playbooks

• Ansible commands
• Running playbooks on local and remote hosts
• Using inventory files
• Using groups and roles

Ansible best practices

• Ansible security
• Ansible troubleshooting
• Ansible orchestration
• Resources for learning more about Ansible

Introduction

• What is Kubernetes and why is it important?
• Key concepts and terminology, such as containers, pods, nodes, deployments, services, and the Kubernetes API
• Kubernetes architecture and components
• Benefits of using Kubernetes, such as scalability, reliability, and efficiency

Kubernetes objects

• Pods: The basic unit of computation and deployment in Kubernetes
• Deployments: A way to manage a set of pods and ensure that they are always running in the desired state
• Services: A way to expose pods to the outside world
• Ingresses: A way to control traffic into Kubernetes services
• Volumes: A way to provide persistent storage to pods

Kubernetes deployments

• Creating and managing deployments
• Rolling updates: A way to update a deployment without downtime
• Blue-green deployments: A way to deploy a new version of an application with zero downtime

Kubernetes services

• Creating and managing services
• Load balancing: A way to distribute traffic across multiple pods
• Service discovery: A way for pods to find each other

Other Kubernetes topics

• Namespaces: A way to isolate Kubernetes resources from each other
• Persistent volumes: A way to provide persistent storage to pods
• Storage classes: A way to manage different types of persistent storage
• Kubernetes monitoring: A way to monitor the health and performance of Kubernetes applications

Lab time

• Set up a Kubernetes cluster using a cloud provider such as Google Kubernetes Engine (GKE) or Amazon Elastic Kubernetes Service (EKS)
• Create and deploy a simple application using Kubernetes
• Scale and update the application
• Monitor the application using Kubernetes monitoring tools

Introduction to Git

• What is Git?
• Basic Git commands
• Git branching and merging
• Git history and diffs

Introduction to GitOps

• What is GitOps?
• Benefits of GitOps
• How GitOps work

Overview of ArgoCD

• What is ArgoCD?
• Features of ArgoCD
• How ArgoCD works

Hands-on with Git:

• Setting up a Git repository
• Creating and pushing commits
• Branching and merging
• Resetting and reverting commits

Hands-on with GitOps:

• Setting up a GitOps workflow
• Creating and managing applications
• Deploying applications to Kubernetes

Hands-on with ArgoCD:

• Installing and configuring ArgoCD
• Creating and managing applications in ArgoCD
• Deploying applications to Kubernetes using ArgoCD

Advanced Git topics

• Git tags
• Git submodules
• Git stash
• Git bisect

Advanced GitOps topics

• GitOps for multiple environments
• GitOps for blue/green deployments
• GitOps for canary deployments

Advanced ArgoCD topics:

• ArgoCD plugins
• ArgoCD rollouts
• ArgoCD security

Case studies:

• How ArgoCD is used by companies of all sizes
• Real-world examples of GitOps workflows

Q&A:

• Opportunity for the agent to ask questions and get help from the trainer

Introduction to Observability

• What is Observability?
• Why is Observability important?
• Benefits of Observability

Introduction to Prometheus

• What is Prometheus?
• Prometheus architecture
• Prometheus components

Installing and configuring Prometheus

• Installing Prometheus
• Configuring Prometheus

Creating and using Prometheus metrics

• Defining metrics
• Collecting metrics
• Storing metrics
• Querying metrics

Prometheus alerts

• Creating alerts
• Configuring alerts
• Managing alerts

Prometheus dashboards

• Creating dashboards
• Adding panels to dashboards
• Configuring dashboards

Prometheus integrations

• Integrating Prometheus with other tools
• Common Prometheus integrations

Prometheus best practices

• Monitoring best practices
• Prometheus best practices

Prometheus troubleshooting

• Common Prometheus problems
• Troubleshooting tips

Hands-on lab

• Setting up a Prometheus environment
• Creating and using Prometheus metrics
• Creating and configuring alerts
• Creating and configuring dashboards

Introduction to Observability and ELK Stack

• Start with an introduction to the concept of observability in modern software systems.
• Explain the role of log data in observability and troubleshooting.
• Introduce the ELK stack components: Elasticsearch, Logstash, and Kibana.
• Discuss the role of each component in the stack and how they work together.

Elasticsearch Fundamentals

• Dive deeper into Elasticsearch, the central component of the ELK stack.
• Explain how Elasticsearch stores and indexes data.
• Cover data types, mappings, and indexing in Elasticsearch.
• Demonstrate basic Elasticsearch queries and search capabilities.
• Discuss the importance of data sharding and replication.

Logstash and Data Ingestion

• Focus on Logstash, the data ingestion and transformation component of ELK.
• Explain how Logstash collects, parses, and enriches log data.
• Show how to create Logstash configuration files to process different log formats.
• Discuss filters, grok patterns, and plugins for data transformation.
• Walk through the process of ingesting data from various sources into Elasticsearch.

Kibana and Data Visualization

• Explore Kibana, the visualization and analytics component of ELK.
• Provide an overview of Kibana's user interface and dashboards.
• Demonstrate how to create visualizations and dashboards in Kibana.
• Discuss the use of Kibana's query language (KQL) for searching and filtering data.
• Showcase advanced features like Canvas for creating custom visualizations.

Introduction to Observability and Distributed Tracing

• Start with an overview of observability in modern software systems.
• Explain the importance of distributed tracing in understanding system behavior.
• Introduce Jaeger and its role in distributed tracing.
• Discuss the key concepts of spans, traces, and traces contexts.
• Demonstrate how to set up and configure Jaeger for tracing.

Hour 2: Jaeger Architecture and Components

• Dive deeper into Jaeger's architecture, including its components like the agent, collector, storage backend, and UI.
• Explain how data flows through these components in a typical Jaeger deployment.
• Show how to deploy Jaeger in various environments (e.g., Kubernetes, Docker).
• Discuss the scalability and high availability considerations.

Instrumenting Applications

• Explore different methods for instrumenting applications to generate traces.
• Demonstrate how to add Jaeger client libraries to popular programming languages (e.g., Python, Java, Go).
• Provide examples of how to create and annotate spans in code.
• Discuss best practices for effective instrumentation.

Querying and Visualization

• Show how to query and analyze traces using the Jaeger UI.
• Explain the query language and filtering options available in Jaeger.
• Discuss how to troubleshoot performance issues using traces.
• Explore integrating Jaeger with other observability tools like Grafana and Prometheus for a comprehensive observability stack.