GCP DevOps for Beginners

Mastering Devops with GCP, Terraform, Github Action, Kubernetes

Cloud DevOps for Beginners: Mastering GCP, Cloud Run, GKE & Cloud Functions

Course Duration: 15 weeks (~6-8 hours/week)

Target Audience: Beginners with no prior cloud or DevOps experience

Prerequisites: Basic Linux commands, Python or Node.js, Git basics

Platform: Google Cloud Platform (GCP), Cloud Run, Google Kubernetes Engine (GKE), Cloud Functions

Tools: GCP Console, Cloud Shell, Docker, Git, GitHub, Cloud Build, Cloud Run, Artifact Registry, Kubernetes, kubectl, Cloud Functions, Cloud Scheduler

Course Objectives

Understand core DevOps concepts (CI/CD, IaC, monitoring)
Gain hands-on experience with GCP services (Cloud Run, GKE, Cloud Functions, Cloud Build, Artifact Registry)
Build and deploy containerized apps using Cloud Run and GKE
Automate infrastructure with Terraform
Implement CI/CD pipelines with Cloud Build and GitHub
Monitor and troubleshoot apps in GCP
Build serverless automation with Cloud Functions and Python
Complete practical mini-projects and capstone projects

Course Outline

Week 1: Introduction to Cloud DevOps and GCP

Objective: Understand DevOps principles and set up a GCP environment.

Topics:

What is DevOps? (Culture, practices, tools)
Cloud DevOps vs. traditional DevOps
GCP overview: Compute, Storage, Networking
Setting up a GCP account and project
Navigating GCP Console and Cloud Shell
Basic gcloud SDK commands

Labs:

Lab 1: Set up a GCP project and configure gcloud SDK
Lab 2: Run basic gcloud commands in Cloud Shell
Lab 3: Host a static website using Cloud Storage

Mini-Project: Host a simple HTML page on a Cloud Storage bucket

Resources:

GCP Free Tier: https://cloud.google.com/free
gcloud SDK: https://cloud.google.com/sdk/docs/install

Week 2: Containers and Cloud Run Basics

Objective: Learn containerization and deploy apps on Cloud Run.

Topics:

Containers and Docker basics
Why Cloud Run? (Serverless, managed containers)
Docker: Images, containers, Dockerfile
Cloud Run: Stateless containers, auto-scaling
Deploying to Cloud Run

Labs:

Lab 1: Install Docker and run a sample container
Lab 2: Write a Dockerfile for a Python/Node.js app
Lab 3: Deploy the app to Cloud Run

Mini-Project: Deploy a “Hello, World!” Flask/Express app to Cloud Run

Resources:

Cloud Run: https://cloud.google.com/run/docs
Docker: https://docs.docker.com/get-started/

Week 3: Version Control and CI/CD with Cloud Build

Objective: Automate deployments with Git and Cloud Build.

Topics:

Git/GitHub: Repositories, commits, branches
CI/CD pipeline concepts
Cloud Build: GCP’s CI/CD service
Connecting GitHub to Cloud Build
Automating Cloud Run deployments

Labs:

Lab 1: Create a GitHub repository and push app code
Lab 2: Set up Cloud Build for automatic builds
Lab 3: Configure cloudbuild.yaml for Cloud Run deployment

Mini-Project: Set up a CI/CD pipeline to deploy the Week 2 app on code changes

Resources:

Cloud Build: https://cloud.google.com/build/docs
GitHub Integration: https://cloud.google.com/build/docs/automating-builds-github

Week 4: Infrastructure as Code (IaC) with Terraform

Objective: Automate GCP resource provisioning with Terraform.

Topics:

IaC concepts and benefits
Terraform: Providers, resources, state
Managing GCP resources (Cloud Storage, Cloud Run)
Terraform best practices

Labs:

Lab 1: Install Terraform and configure GCP provider
Lab 2: Create a Cloud Storage bucket with Terraform
Lab 3: Deploy a Cloud Run service using Terraform

Mini-Project: Provision a Cloud Run service and Cloud Storage bucket with Terraform

Resources:

Terraform GCP: https://registry.terraform.io/providers/hashicorp/google/latest/docs
Terraform Basics: https://learn.hashicorp.com/terraform

Week 5: Artifact Registry and Container Management

Objective: Store and manage container images securely.

Topics:

Artifact Registry overview
Storing Docker images
Integrating with Cloud Run and Cloud Build
Image versioning

Labs:

Lab 1: Create an Artifact Registry repository
Lab 2: Push a Docker image to Artifact Registry
Lab 3: Update Cloud Build to use Artifact Registry images

Mini-Project: Store Week 2 app images in Artifact Registry and deploy to Cloud Run

Resources:

Artifact Registry: https://cloud.google.com/artifact-registry/docs

Week 6: Monitoring and Logging in GCP

Objective: Monitor and troubleshoot Cloud Run apps.

Topics:

Cloud Monitoring and Cloud Logging
Metrics and alerts for Cloud Run
Debugging logs
Scaling and performance tuning

Labs:

Lab 1: Enable Cloud Logging for the Week 2 app
Lab 2: Create a custom metric for HTTP requests
Lab 3: Set up an alert for high error rates

Mini-Project: Create a Cloud Monitoring dashboard and alert for the Week 2 app

Resources:

Cloud Monitoring: https://cloud.google.com/monitoring/docs
Cloud Logging: https://cloud.google.com/logging/docs

Week 7: Security and Best Practices

Objective: Secure apps and infrastructure in GCP.

Topics:

GCP IAM
Securing Cloud Run (authentication, HTTPS)
Secret Manager for sensitive data
DevOps best practices

Labs:

Lab 1: Create an IAM role for Cloud Run access
Lab 2: Store an API key in Secret Manager
Lab 3: Enable authentication for Cloud Run

Mini-Project: Secure the Week 2 app with Secret Manager and IAM

Resources:

Secret Manager: https://cloud.google.com/secret-manager/docs
IAM: https://cloud.google.com/iam/docs

Week 8: Capstone Project – Cloud Run Application

Objective: Apply all concepts in a real-world project.

Topics:

DevOps workflow review
Production-ready app best practices
Cost optimization in GCP
Preparing for DevOps roles and certifications

Capstone Project: Build and deploy a Todo List web app:

Containerize a Flask/Express app with frontend and backend
Store images in Artifact Registry
Set up a CI/CD pipeline with Cloud Build
Provision resources with Terraform
Use Secret Manager for sensitive data
Monitor with Cloud Monitoring and secure with IAM
Deploy to Cloud Run and provide a public URL

Deliverables:

GitHub repository with code, Dockerfile, and Terraform scripts
Documentation of CI/CD and monitoring setup
Live demo of the app

Wrap-Up:

Key takeaways and next steps (e.g., GCP Associate Cloud Engineer certification)

NEW CONTENT: Weeks 9-15

Week 9: Introduction to Kubernetes and GKE

Objective: Understand Kubernetes fundamentals and set up a GKE cluster.

Topics:

What is Kubernetes? (Orchestration, pods, services, deployments)
Cloud Run vs. GKE: When to use each
GKE overview and architecture
Kubernetes objects: Pods, Services, Deployments, ConfigMaps, Secrets
kubectl basics
Creating and managing GKE clusters

Labs:

Lab 1: Create a GKE cluster using GCP Console and gcloud
Lab 2: Install and configure kubectl
Lab 3: Deploy a simple nginx app to GKE
Lab 4: Expose the app using a LoadBalancer service

Mini-Project: Deploy a multi-container app (frontend + backend) to GKE with separate services

Resources:

GKE Documentation: https://cloud.google.com/kubernetes-engine/docs
Kubernetes Basics: https://kubernetes.io/docs/tutorials/kubernetes-basics/

Week 10: GKE Deployments and Scaling

Objective: Master deployments, scaling, and updates in GKE.

Topics:

Kubernetes Deployments and ReplicaSets
Horizontal Pod Autoscaling (HPA)
Vertical Pod Autoscaling (VPA)
Rolling updates and rollbacks
Health checks (liveness and readiness probes)
Resource requests and limits

Labs:

Lab 1: Create a deployment with multiple replicas
Lab 2: Configure HPA to scale based on CPU usage
Lab 3: Perform a rolling update and rollback
Lab 4: Add liveness and readiness probes

Mini-Project: Deploy a microservices app (3+ services) with auto-scaling and health checks

Resources:

Kubernetes Deployments: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
GKE Autoscaling: https://cloud.google.com/kubernetes-engine/docs/concepts/horizontalpodautoscaler

Week 11: GKE Networking and Ingress

Objective: Configure networking, load balancing, and ingress in GKE.

Topics:

Kubernetes networking model
Service types (ClusterIP, NodePort, LoadBalancer)
Ingress controllers and GKE Ingress
Network policies for security
DNS and service discovery
SSL/TLS certificates with GKE Ingress

Labs:

Lab 1: Create different service types and test connectivity
Lab 2: Set up GKE Ingress with path-based routing
Lab 3: Configure SSL certificates for HTTPS
Lab 4: Implement network policies to restrict traffic

Mini-Project: Deploy a multi-service app with Ingress routing, SSL, and network policies

Resources:

Kubernetes Services: https://kubernetes.io/docs/concepts/services-networking/service/
GKE Ingress: https://cloud.google.com/kubernetes-engine/docs/concepts/ingress

Week 12: GKE CI/CD and GitOps

Objective: Automate GKE deployments with CI/CD and GitOps practices.

Topics:

CI/CD for Kubernetes
Cloud Build for GKE deployments
Helm: Package manager for Kubernetes
GitOps principles and tools (Config Sync)
Skaffold for local development
Kubernetes manifests with Kustomize

Labs:

Lab 1: Create a Cloud Build pipeline for GKE deployment
Lab 2: Package an app with Helm and deploy to GKE
Lab 3: Set up GitOps with Config Sync
Lab 4: Use Skaffold for local development workflow

Mini-Project: Build a complete CI/CD pipeline that automatically deploys to GKE on Git commits using Cloud Build and Helm

Resources:

Cloud Build for GKE: https://cloud.google.com/build/docs/deploying-builds/deploy-gke
Helm: https://helm.sh/docs/
Config Sync: https://cloud.google.com/anthos-config-management/docs/config-sync-overview

Week 13: Introduction to Cloud Functions and Serverless Automation

Objective: Build event-driven serverless functions with Python.

Topics:

Serverless computing concepts
Cloud Functions overview (Gen 1 vs Gen 2)
Function triggers (HTTP, Pub/Sub, Cloud Storage, Cloud Scheduler)
Python for Cloud Functions
Environment variables and dependencies
Error handling and retries

Labs:

Lab 1: Create a simple HTTP-triggered Cloud Function in Python
Lab 2: Deploy a Cloud Storage-triggered function (process uploaded files)
Lab 3: Create a Pub/Sub-triggered function
Lab 4: Schedule a function with Cloud Scheduler

Mini-Project: Build an automated image processing pipeline (upload to Cloud Storage → trigger function → resize image → save to another bucket)

Resources:

Cloud Functions: https://cloud.google.com/functions/docs
Cloud Functions Python: https://cloud.google.com/functions/docs/writing/write-python-functions

Week 14: Advanced Cloud Functions and Automation Projects

Objective: Build complex automation workflows with Cloud Functions and Python.

Topics:

Chaining Cloud Functions with Pub/Sub
Integrating with GCP services (BigQuery, Firestore, Cloud SQL)
Cloud Workflows for orchestration
Using external APIs in Cloud Functions
Logging and monitoring for Cloud Functions
Cost optimization strategies

Labs:

Lab 1: Build a data pipeline (Cloud Storage → Cloud Function → BigQuery)
Lab 2: Create a Slack bot with Cloud Functions and HTTP triggers
Lab 3: Automate GCP resource management (start/stop VMs on schedule)
Lab 4: Implement error handling and DLQ (Dead Letter Queue)

Mini-Project: Build a serverless ETL pipeline:

CSV files uploaded to Cloud Storage
Cloud Function validates and transforms data
Publishes to Pub/Sub
Another function loads data into BigQuery
Send Slack notification on completion

Resources:

Cloud Workflows: https://cloud.google.com/workflows/docs
BigQuery Python Client: https://cloud.google.com/bigquery/docs/reference/libraries

Week 15: Final Capstone Project – Full-Stack Cloud DevOps Application

Objective: Build and deploy a complete, production-ready cloud-native application using all learned technologies.

Final Capstone Project: E-commerce Inventory Management System

Requirements:

Application Architecture:
- Frontend: React/Vue app (containerized)
- Backend API: Python Flask/FastAPI (containerized)
- Database: Cloud SQL (PostgreSQL)
- File Storage: Cloud Storage
- Microservices: At least 3 services deployed on GKE
GKE Deployment:
- Deploy microservices to GKE with proper service mesh
- Configure Ingress with SSL/TLS
- Implement HPA for auto-scaling
- Use ConfigMaps and Secrets for configuration
Cloud Functions Automation:
- Function 1: Process inventory updates (CSV uploads)
- Function 2: Send email notifications for low stock
- Function 3: Daily report generation (scheduled)
- Function 4: Image optimization for product photos
Infrastructure as Code:
- Provision all GCP resources with Terraform
- Include GKE cluster, Cloud Functions, Cloud Storage, Cloud SQL
- Organize code with modules
CI/CD Pipeline:
- Cloud Build for automated builds and deployments
- Separate pipelines for GKE services and Cloud Functions
- Automated testing before deployment
- Use Helm for Kubernetes deployments
Monitoring & Security:
- Cloud Monitoring dashboards for GKE and Cloud Functions
- Log-based alerts for errors
- IAM roles with least privilege
- Secret Manager for sensitive data
- Network policies for GKE
Documentation:
- Architecture diagram
- Setup and deployment instructions
- API documentation
- Monitoring and troubleshooting guide

Deliverables:

GitHub repository with complete source code
Terraform scripts for infrastructure
Kubernetes manifests and Helm charts
Cloud Build configuration files
Comprehensive README with setup instructions
Live demo URL for the application
Presentation (10-15 minutes) showcasing the project

Evaluation Criteria:

Functionality and completeness (30%)
Code quality and best practices (20%)
Infrastructure automation (20%)
CI/CD implementation (15%)
Monitoring and security (10%)
Documentation (5%)

Wrap-Up Session:

Project presentations and peer feedback
Review of DevOps best practices
Career guidance for DevOps roles
Next steps: GCP certifications (Associate Cloud Engineer, Professional Cloud DevOps Engineer)
Advanced topics to explore (Service Mesh, Anthos, Cloud Composer)

Learning Resources

Core Resources

GCP Free Tier: https://cloud.google.com/free
Qwiklabs: https://www.qwiklabs.com/
Docker: https://docs.docker.com/
Terraform: https://www.terraform.io/docs
GitHub Learning Lab: https://lab.github.com/

Kubernetes & GKE Resources

Kubernetes Documentation: https://kubernetes.io/docs/
GKE Documentation: https://cloud.google.com/kubernetes-engine/docs
Kubernetes Patterns (book): https://k8spatterns.io/
kubectl Cheat Sheet: https://kubernetes.io/docs/reference/kubectl/cheatsheet/

Cloud Functions Resources

Cloud Functions Documentation: https://cloud.google.com/functions/docs
Python Client Libraries: https://cloud.google.com/python/docs/reference
Serverless Framework: https://www.serverless.com/framework/docs

Additional Learning

Google Cloud Skills Boost: https://www.cloudskillsboost.google/
A Cloud Guru: https://acloudguru.com/
Cloud DevOps Slack Communities
Google Cloud YouTube Channel

Assessment and Certification

Weekly Assessments

Weekly quizzes on DevOps, GCP, Kubernetes, and serverless concepts
Graded mini-projects (Weeks 1-14)
Two capstone projects (Week 8 and Week 15)

Grading Breakdown

Weekly quizzes: 20%
Mini-projects: 30%
Capstone Project 1 (Week 8): 20%
Final Capstone Project (Week 15): 30%

Certification

Course completion certificate (minimum 70% overall grade)
Badge for completing both capstone projects
Recommendation for GCP Associate Cloud Engineer exam

Why This Course Structure?

Cloud Run (Weeks 1-8)

Simplifies container management vs. Kubernetes
Serverless and auto-scaling
Cost-effective for beginners using GCP Free Tier
Perfect for learning containerization basics

GKE (Weeks 9-12)

Industry-standard container orchestration
Essential for microservices architecture
Advanced scaling and networking capabilities
Prepares for enterprise DevOps roles

Cloud Functions (Weeks 13-14)

Event-driven serverless computing
Perfect for automation and integrations
Cost-effective for sporadic workloads
Complements containerized applications

Full Integration (Week 15)

Real-world application combining all technologies
Portfolio-ready project for job applications
Demonstrates end-to-end DevOps proficiency

Prerequisites Reminder

Basic Linux commands
Python or Node.js fundamentals
Git basics (clone, commit, push)
Basic understanding of HTTP and REST APIs

Tools You’ll Need

Computer with 8GB+ RAM
GCP account with free tier
GitHub account
Docker Desktop (local development)
Text editor/IDE (VS Code recommended)
Terminal/command line access

Success Tips

Practice Daily: Spend at least 1 hour per day on labs and projects
Use Free Tier Wisely: Stay within GCP free tier limits to avoid charges
Document Everything: Keep notes and document your setup steps
Join Communities: Participate in GCP and DevOps forums
Build Portfolio: Upload all projects to GitHub
Don’t Skip Labs: Hands-on practice is essential
Review Weekly: Revisit previous weeks’ content regularly
Ask Questions: Use course forums and office hours

Career Outcomes

After completing this course, you’ll be prepared for:

Junior DevOps Engineer
Cloud Engineer
Site Reliability Engineer (SRE)
Platform Engineer
Kubernetes Administrator
Automation Engineer

Average Salary Range: $70,000 – $110,000 (entry-level, varies by location)

Next Steps After Completion

Certifications:
- Google Cloud Associate Cloud Engineer
- Google Cloud Professional Cloud DevOps Engineer
- Certified Kubernetes Administrator (CKA)
Advanced Topics:
- Service Mesh (Istio, Anthos Service Mesh)
- Advanced Terraform (workspaces, remote state)
- GitOps with ArgoCD or Flux
- Cloud Composer (Apache Airflow)
- Serverless Containers (Cloud Run for Anthos)
Build More Projects:
- Open-source contributions
- Personal portfolio site with CI/CD
- Multi-cloud deployments
- Advanced microservices architectures