Free certifications

Published: Draft

Written By: Ng Jun Hao

Background

One of the best ways to start learning anything is through free resources online. I found some free resources from Google Cloud and The Linux Foundation to begin my journey. They are linked below.

Google Cloud - DevOps Essentials

Accelerate the state of DevOps 2019
- Reports from research by Google
Managing Deployments Using Kubernetes Engine
- Use the kubectl tool
  - kubectl explain deployment - Tell us about the deployment object
- Create deployment yaml files
  - Configure deployments/auth.yaml
- Launch, update, and scale deployments
  - kubectl create -f deployments/auth.yaml - Create a deployment object (Manage application)
  - kubectl get deployments - Verify deployments
  - kubectl get replicasets - Verify ReplicaSet
  - kubectl get pods - Verify pods created by ReplicaSet
  - kubectl create -f services/auth.yaml - Create the auth service (Manage networking)
  - kubectl create secret generic tls-certs --from-file tls/ - Create secrets to store sensitive information
  - kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf - Create ConfigMap to store non-sensitive application configurations
- Update deployments and learn about deployment styles
  - Scale a deployment
    - kubectl explain deployment.spec.replicas
    - kubectl scale deployment hello --replicas=5 - Scale from 3 replicas to 5
    - kubectl get pods | grep hello- | wc -l - Check number of pods
  - Rolling update
    - kubectl edit deployment hello - Edit the deployment
    - kubectl get replicaset - Check
    - kubectl rollout history deployment/hello - Deploy
    - You can also pause, resume and rollback
  - Canary update
    - cat deployments/hello-canary.yaml - Configure
    - kubectl create -f deployments/hello-canary.yaml - Create
  - Blue-Green deployment
    - kubectl create -f deployments/hello-green.yaml - Create green
    - kubectl apply -f services/hello-blue.yaml - Switch to blue
Deploy Kubernetes Load Balancer Service with Terraform
- With the tf file, run terraform init
Continuous Delivery with Jenkins in Kubernetes Engine
- When updates is pushed, Jenkins will auto build and deploy the application

The Linux Foundation - Introduction to DevOps and Site Reliability Engineering

Introduction to DevOps and SRE
- What is DevOps and SRE? - DevOps focuses on creating new features and improvements while SRE ensures everything runs smoothly behind the scenes
- Pre-DevOps Era - Waterfall model, Siloed teams, Manual processes, Limited automation, Slow and unreliable delivery
- DevOps Era
  - Factors for emergence of devops: Need for faster software delivery, Inefficiencies of siloed teams, Rise of automation tools, Cloud computing
  - Key principles: Collaboration, Automation, CI/CD, IaC, Monitoring and feedback
  - Benefits of DevOps: Speed, Rapid delivery, Reliability, Scalability, Improved collaboration, Security, Improved customer satisfaction, Cost savings
  - Tools in DevOps: Version control, CI/CD, Configuration management, Containerization and orchestration, Infrastructure as Code, Continuous monitoring, Collaboration and communication, Logging, Source control management (SCM)
  - Future of DevOps: AI-powered automation, Security-first approach, Shift towards self-service platforms, Rise of low-code/no-code tools, Focus on observability and monitoring, Collaboration across the entire value chain, Embracing the “everything as code” (EaC) approach, Continuous learning and upskilling
  - Challenges and Opportunities: Managing the complexity of new technologies, Ensuring security in a rapidly evolving environment, Fostering a culture of collaboration and shared responsibility
Introduction to cloud
- Why Should You Bother?
  - Scaling Success with Flexibility
  - Rapid Prototyping and Innovation
- Types of cloud
  - Infrastructure as a Service (IaaS)
  - Platform as a Service (PaaS)
  - Software as a Service (SaaS)
  - Function as a Service (FaaS)
- Cloud Deployment Models
  - Public Cloud
  - Private Cloud
  - Hybrid Cloud
  - Community Cloud
  - Multi-Cloud
- Major Cloud Services
  - Compute Services
  - Storage Services
  - Database Services
  - Networking Services
  - Security and Identity Services
  - Machine Learning and Artificial Intelligence Services
  - Serverless Computing
  - IoT (Internet of Things) Services
  - DevOps and CI/CD Services
  - Analytics and Big Data Services
Introduction to containers and kubernetes
- Containers and Virtual Machines
  - Virtual Machines: Isolated and Versatile
  - Containers: Lightweight and Efficient
- Docker
  - Docker Engine, Docker Client, Docker Images, Docker Registry, Docker Compose, Docker Swarm, Networking and Storage Drivers
- Kubernetes: The Orchestrator of Containerized Applications
  - Control Plane Node
  - Worker Node
  - Pod
  - ReplicaSet
  - Deployment
  - Service
  - Volume
  - Namespace
  - ConfigMap and Secret
Infrastructure as Code (IaC)
- Why? Agility and Innovation, Reliability and Stability, Resource Optimization and Cost Savings
- Categories of IaC tools
  - Declarative IaC Tools: Terraform, Pulumi
  - Configuration Management Tools: Ansible, Chef
  - Container Orchestration Tools
  - Cloud Native IaC Tools
  - Considerations for Choosing IaC Tools
- Features of IaC Tools
  - Declarative Configuration
  - Idempotent Operations
  - Version Control Integration
  - Dependency Management
  - Parallel Execution
- Introduction to Terraform
  - Terraform is a powerful open source IaC tool that lets you define your infrastructure in human-readable configuration files, instead of manually clicking through clunky web interfaces, you write code that describes the infrastructure you need.
- Introduction to OpenTofu
  - Forked from Terraform
- AWS CloudFormation is a powerful Infrastructure as Code (IaC) service offered by Amazon Web Services (AWS)
Continuous Integration/Continuous Delivery (CI/CD)
- Meaning
  - CI involves the regular merging of code changes from multiple contributors into a shared repository
  - Continuous Delivery is a software development practice that extends the principles of Continuous Integration to ensure that the codebase is always in a deployable state.
- Continuous Integration (CI) Principles: Frequent Code Integration, Automated Builds, Automated Testing, Immediate Feedback
- Continuous Integration (CI) Practices: Version Control, Automated Builds, Automated Testing, Continuous Integration Server
- Continuous Delivery (CD) and Continuous Deployment (CD) Principles: Consistent Deployment Process, Automated Deployment, Environment Parity
- Continuous Delivery (CD) and Continuous Deployment (CD) Practices: Continuous Delivery, Continuous Deployment, Feature Toggles, Rollback Mechanisms, Monitoring and Logging
- Release Strategies: Rolling Release, Feature Toggles (Feature Flags), Blue-Green Deployment, Canary Release, Phased (Staged) Rollout
- GitOps: Deployment methodology that leverages Git as a single source of truth for infrastructure and application configuration
Introduction to observability
- Observability is the ability to understand the internal state of a system based on its external outputs
- The Three Pillars of Observability: Logs, Metrics, Traces
- Why observability: Complexity of Modern Systems, Faster Incident Resolution, Improved User Experience, Improved Troubleshooting, Enhanced Performance, Reduced Costs
- Components of an Observability Stack: Data Collection, Data Storage and Management, Data Analysis and Visualization
- Observability in DevOps and SRE: Continuous Monitoring, Feedback Loops, Collaboration Across Teams, Infrastructure as Code (IaC)
- Challenges in Observability: Data Volume and Overhead, Integration Complexity, Lack of Standardization, Complex Distributed Systems, Security and Privacy Concerns, Alert Fatigue, Tool Proliferation, Cultural Resistance
- Observability Tools: Monitoring and Metrics, Logging, Tracing, Application Performance Monitoring (APM), Infrastructure Monitoring, Cloud Native Observability
Site Reliability Engineering (SRE)
- What is SRE? Site Reliability Engineering (SRE) is an approach to running large-scale, reliable services
- Reliability is often measured through service level indicators (SLIs), service level objectives (SLOs), and service level agreements (SLAs)
- Measuring Reliability with SLIs
  - Latency: The time it takes for a request to be processed
  - Availability: The percentage of time the service is operational
  - Error Rate: The proportion of requests that result in errors
- Embracing Risks with SLOs and Error Budgets
  - For example, an SLO for availability might be set at 99.9%, indicating that the service should be available 99.9% of the time.
- Service Level Agreements (SLAs)
  - An SLA is a formal contract between a service provider and its customers, outlining the expected level of service.
- The 7 Principles of SRE
  - Embracing Risk
  - Service Level Objectives (SLOs)
  - Simplicity
  - Toil Automation
  - Monitoring and Alerting
  - Capacity Planning
  - Emergency Response and Blameless Postmortems
- Building SRE Practices
  - Gain buy-in and support
  - Start small and iterate
  - Build a dedicated SRE team
  - Embrace automation and tooling
  - Cultivate a blameless culture
  - Continuously improve and evolve
- Future Trends and Evolutions in SRE
  - AI and Machine Learning Integration
  - Observability over Monitoring
  - DevSecOps Integration
  - Broader Organizational Impact
  - Cloud Native Reliability
  - Sustainable Operations

The Linux Foundation - Labs for Introduction to DevOps and Site Reliability Engineering

Create Google Cloud Compute Engine VM
Docker, Podman, and Kubernetes
Installing Terraform and OpenTofu
Setting Up Jenkins
Setting Up Prometheus and Grafana

Summary

In the future, I hope to obtain paid certifiations from cloud providers like Google, Microsoft and Amazon.

Resources

Back to home