Google Cloud Developer - GCP Professional Certification

Discover cloud fundamentals by understanding why enterprises move from data centers to cloud platforms and how servers enable scalable, reliable applications.

Discover why enterprises need thousands of servers instead of a single one, exploring server types, limits, single points of failure, and hosting in data centers.

Understand that a data center is a secure facility with specialized infrastructure—power, cooling, networking, and security for servers—and why upfront costs and capacity guessing push cloud adoption for instant access.

Discover how cloud computing shifts from owning infrastructure to renting resources on demand, with elasticity and pay as you go pricing.

Explore how cloud providers' scale enables pay for use, economies of scale, and elastic capacity to go global in minutes, boost agility, and avoid undifferentiated heavy lifting.

Master key cloud terms such as elasticity, agility, geo distribution, availability, latency, and CapEx to OpEx switching, plus pay-as-you-go benefits, to improve global reach and resource efficiency.

Explore elasticity, pay as you go opex, agility, and availability; and examine geo distribution, low latency, economies of scale, and avoiding undifferentiated heavy lifting in cloud deployments.

Explore Google Cloud's heritage and private fiber optic network, delivering data over Google's own infrastructure for faster, more secure connections, with leading analytics and AI capabilities.

Discover a structured step-by-step path to learning cloud services across AWS, Azure, and Google Cloud with a practical gateway: a cloud account offering free beginner credits.

Create a Google Cloud account and start the free trial with $300 credit by entering your personal details, verifying your mobile number, and providing card and tax information.

Explore regions and zones, understand why multiple regions and availability zones matter for latency and availability, and see how cloud providers offer global regions to host data centers.

Evaluate compliance, data locality, latency, service availability, and pricing when choosing a deployment region. Keep data local where required, place regions near users, and verify service availability and regional pricing.

Deploy your applications to multiple regions to reduce latency, expand the global footprint, meet data residency rules, and boost availability and disaster recovery.

Deploy across multiple zones within the same region to achieve high availability and fault tolerance. Zones are isolated within the region, with independent power and networking.

Learn how regions and zones enable disaster recovery, data residency, and low-latency access by deploying across multiple zones within a region and across multiple regions.

Explore Google Cloud regions and zones, including us west one a, europe north one, and asia south one, and learn how deploying across multiple zones and regions enhances high availability.

Launch your first Google Compute Engine virtual machine, automate deployment with startup scripts, instant templates, and custom images, and explore cost optimization, high availability, and best practices.

Explore Google Compute Engine to provision and manage virtual machines, implement load balancing and auto scaling, attach storage, and configure network connectivity for scalable web deployments.

Create and manage Google Compute Engine VMs via the cloud console, practicing start, stop, restart, and SSH. Learn to set labels, region, machine type, and HTTP traffic, while tracking costs.

Choose VM hardware by selecting a machine family and type, and pick software with public or custom images. Access the VM via external IP and SSH to run commands.

Install Apache on a Google Compute Engine VM, update packages, and customize /var/www/html/index.html to show host name and IP.

Explore how internal and external IP addresses function for a Google Cloud VM, noting external IPs are internet addressable and unique, change after stopping and restarting; internal IPs stay local.

Reserve and assign a regional IPv4 static external IP to a Google Cloud VM, so the address remains after restarts.

Switch a static IP between VM instances within the same project and keep the address attached when you stop a VM. Release unused static IPs to avoid higher bills.

Bootstrap a Google Cloud VM with a startup script to automatically install the Apache HTTP server and enable HTTP traffic, and compare instance templates and custom images.

Simplify instance creation with templates that define machine type, image or image family, startup script, and labels, enabling rapid deployment of single virtual machines or groups.

Create a custom, hardened image with OS patches and pre-installed software to reduce boot time, then deploy via instance templates to launch secure VMs without startup scripts.

Debug Apache on a GCP VM by verifying the external IP, SSHing in, checking index.html, starting Apache with sudo, and enabling HTTP traffic in the firewall.

Explore how to reduce Compute Engine costs with sustained use discounts, committed use discounts, and preemptible VMs, including automatic pricing, reservation options, and best-fit workloads.

Achieve high availability with live migration that moves a running VM to another host in the same zone during on-host maintenance, and configure availability policy for migrate and automatic restart.

Navigate the Google Cloud Platform web console, pin favorites so Compute Engine appears at the top. Review the dashboard and project settings to manage resources.

Select VM regions and zones to balance cost, regulations, latency, and hardware needs; distribute across zones for high availability; choose CPU, memory, or GPU types by workload, and label VMs.

Identify prerequisites for creating a virtual machine: a project, a billing account, and enabled compute engine API; explore sole-tenant nodes, VM Manager for large fleets, and firewall considerations.

Review Google Compute Engine concepts, including images and custom hardened images, machine types, static IPs, instance templates, and discounts like sustained usage, committed use, and preemptible VMs.

Develop deep work by achieving a flow state of concentrated focus that maximizes efficiency and accelerates learning, using a distraction-free environment and 2 to 3 hours every week.

Learn to create multiple virtual machines with managed instance groups, perform rolling updates, and design Google Cloud load balancing to distribute traffic across instances.

Learn to manage identical virtual machines with managed instance groups, templates, auto scaling, health checks, and rolling updates with canary deployment for releases without downtime.

Learn to create a managed instance group from an instance template, configure auto scaling with CPU or load balancer metrics, and set health checks and auto healing.

Learn to work with a Google Cloud managed instance group, enabling auto healing and health checks, and adjust minimum and maximum instances across zones.

Explore rolling updates and canary testing for managed instance groups, including proactive and opportunistic update strategies, max surge and max unavailable, and rolling restart or replace of VMs.

Explore cloud load balancing to distribute traffic across VM instances in single or multiple regions, with health checks, autoscaling, internal load balancing, and a single anycast IP for high availability.

Create a Google Cloud http/https load balancer to distribute traffic to a managed instance group. Configure the backend service, host and path rules, and the front end with health checks.

Explore cloud load balancing terminology, including backends (managed instance groups), front end, host and path rules, and SSL/TLS termination, with examples for routing to microservices.

Explore how a Google Cloud load balancer distributes traffic across a managed instance group using an instance template and backend service, with health checks and monitoring.

Learn to choose the right Google Cloud load balancer by traffic type and protocol, comparing internal versus external options, and regional versus global deployments with advanced traffic management.

Explore load balancing scenarios across multi-region deployments, health checks, and path-based routing for microservices, with regional managed instance groups, per-service backends, storage bucket routing, and SSL termination options.

Learn to use gcloud, the Google Cloud command-line interface, to manage compute resources and deployments; install the sdk or use Cloud Shell, and configure project, account, region, and zone.

Explore the gcloud command structure—groups, subgroups, and actions—for managing compute services like instances. Learn to list, create, describe, and delete compute instances, and filter machine types by zone and region.

Cloud shell runs on a Google Compute Engine VM with a 5 GB persistent home, preinstalled Cloud SDK and Docker, files persisting across sessions, and supports SSH via private IPs.

Explore how managed cloud services simplify deployment and learn service models, including infrastructure as a service, platform as a service, function as a service, container as a service, and serverless.

Compare infrastructure as a service (IaaS) and platform as a service (PaaS), where you manage application code and runtime on IaaS, while provider handles OS, runtime, and scaling in PaaS.

Explore containers and microservices, and learn how Docker images package apps and runtimes for consistent deployment on Kubernetes with autoscaling, service discovery, load balancing, and zero-downtime releases.

Learn what serverless really means—focus on your code while cloud services handle deployment, scaling, and availability, with pay-for-use pricing and examples like AWS Lambda, Azure Functions, and Google Functions.

Explore the 10,000-foot overview of Google Cloud compute services, including Compute Engine, Google Kubernetes Engine, App Engine, Cloud Functions, and Cloud Run.

Discover App Engine, a Google Cloud managed platform that auto scales, balances load, supports multiple runtimes and containers, and offers versioning and traffic splitting for easy deployment.

Explore App Engine environments, comparing standard and flexible: standard uses language-specific sandboxes with V1/V2 limits, while flexible runs Docker containers and supports any runtime.

Define the App Engine component hierarchy, where the application is the container for services, each service can have multiple versions, with instances, traffic split, and rollback options.

Compare App Engine standard and flexible environments, highlighting pricing, scaling options, startup times, and storage, noting standard's scale to zero and rapid startup versus flexible's minimum one instance.

Configure automatic scaling for continuous workloads based on CPU or throughput with min and max instances; basic scaling suits ad hoc workloads, while manual scaling is for predictable load.

Create a new Google Cloud project, enable App Engine APIs, configure app.yaml and main.py, and deploy the Python app to App Engine standard using gcloud.

Explore App Engine in GCP by viewing the dashboard, managing services and versions, deploying v2 with traffic split, and listing services, versions, and instances via gcloud.

Deploy a new app engine version with no-promote, test v3, and gradually split traffic between v2 and v3 using IP, random, or cookie methods.

Create and manage multiple App Engine services and versions, deploy with gcloud app deploy, configure service names in app.yaml, and control traffic and URLs via UI or command line.

Configure app engine app.yaml to set run time, api version, and instance class, enable a flex environment and environment variables, and define automatic, basic, or manual scaling.

Create and deploy cron jobs in App Engine using cron.yaml to run scheduled http get requests at intervals, such as daily emails or cache refreshes, via gcloud app deploy cron.yaml.

Learn how to deploy new App Engine versions without downtime by shifting traffic from V1 to V2 or using no promote deployment, gradual migration, or traffic splitting for AB testing.

Recognize App Engine is regional, cannot change regions or be moved between projects, and use standard v2 with a mix of resident and dynamic instances for scale to zero.

Explore App Engine scenarios: one app per project, multiple services and versions, region constraints, and traffic strategies, including max instances in app.yaml and no promote deployments.

Identify your learning style by reading a book first, then watching an expert video, with hands-on optional. Adopt this approach to learn efficiently and stay relevant in the technology landscape.

Explore the fundamentals of Google Kubernetes Engine, covering clusters, nodes, node pools, deployment, pods, service, replica sets, autoscaling, config maps, secrets, namespaces, service discovery, and troubleshooting.

Explore Google Kubernetes Engine (GKE), the managed Kubernetes service on Google Cloud, and master cluster management, upgrades, port and cluster autoscaling, plus Cloud Logging and Monitoring.

Begin a hands-on journey to deploy a microservice by creating a GKE cluster with a default node pool, enabling Kubernetes APIs, and selecting standard or autopilot mode.

Connect to a Google Kubernetes cluster and deploy a dockerized microservice with kubectl. Expose it with a load balancer and test the hello world rest api on port 8080.

Explore the GKE console to view clusters, nodes and node pools, deployments and pods, and learn to expose apps with services and ingresses, using yaml or kubectl.

Scale deployments with kubectl by setting replicas for hello-world-rest-api, enabling service-based load balancing across pods; then resize the cluster node pool with gcloud in us-central1-c.

Learn to auto scale deployments and clusters with kubectl, implement horizontal pod autoscalers, and configure settings using configmaps and secrets for scalable, secure microservices.

Edit deployment yaml to set replicas and deploy with kubectl apply -f deployment.yaml. Compare imperative commands with declarative yaml, and review deployment and service configurations, including load balancer type.

Deploy a GPU-enabled microservice by creating a new node pool and using a node selector to target it in the deployment. Conclude by managing clusters with gcloud and cloud console.

Explore how Kubernetes clusters run workloads in Google Kubernetes Engine, detailing master nodes and the control plane components, worker nodes, pods, deployments, replica sets, and zonal, regional, private clusters.

Discover how pods are the smallest deployable units in Kubernetes, housing one or more containers with ephemeral IPs and sharing network, storage, and ports across a deployment's pods.

Learn how deployments manage multi-version microservices with zero downtime, while replica sets ensure a fixed number of v1 and v2 pods and handle image upgrades.

Explore how Kubernetes services maintain stable external access amid internal changes by exposing deployments via cluster IP, load balancer, or node port, and using ingress to route traffic.

Discover how Kubernetes namespaces partition a single cluster into virtual groups, isolating deployments and enabling team-specific permissions. Learn to list, create, and assign resources to namespaces via kubectl and YAML.

Discover how Kubernetes enables service discovery for microservices to talk without hard-coded URLs, using the FQDN like service-name.namespace.svc.cluster.local, or service names in the same namespace, with automatic internal load balancing.

Troubleshoot Kubernetes deployment errors by diagnosing image pull back off due to wrong image name or registry access, inspect logs, run kubectl commands, and resolve pod unschedulable scaling issues.

Learn key best practices for Google Kubernetes Engine, including high availability with multi-zone master nodes, docker image workflows, and using statefulset, daemonset, and cloud monitoring for logs and metrics.

Review key Kubernetes terminology across hardware and software components. Understand clusters, master and worker nodes, node pools, pods, deployments, and services, and how deployments manage pods and expose apps.

Optimize GKE costs with preemptible VMs, region choices, committed use discounts, and E2 machines. Use GPU node pools and autoscale with horizontal pod autoscaler and cluster autoscaler.

Master declarative YAML in Google Kubernetes Engine, configuring deployments, services, and labels, then explore advanced topics like deployment strategy, ingress, volumes, and network policies.

Learn the basics of declarative Kubernetes configuration with YAML, covering API version, kind, metadata, labels, and specs for deployments and services.

Translate command-based deployments into declarative Kubernetes yaml, mapping image and three replicas to a deployment name, and define a pod template with container image, name, and labels.

Explore Kubernetes service YAML by configuring ports, selectors, and types, including load balancer and external access, mapping the container port 8080 to the external port 8080.

Explore how Kubernetes YAML uses labels as key-value pairs attached to objects to map deployments to pods and services to pods using app Hello World REST API label via selectors.

Connect to the Kubernetes cluster, view and describe the hello world rest api service and deployment, and delete resources by name or by the label app=hello world REST API.

Apply declarative Kubernetes configuration to create deployments and a load-balanced service, using deployment.yaml and deploymentV2.yaml, with labels to route traffic between versions V1 and V2.

Learn how Kubernetes uses readiness and liveness probes to manage traffic and keep pods healthy, using health check URLs that return a 200 response.

Learn how Kubernetes deployment strategy uses rolling update to update pods in batches. Configure maxSurge and maxUnavailable to control capacity and downtime; compare rolling update with recreate for safe releases.

Explore Kubernetes ingress, enabling a single external load balancer to route traffic to multiple microservices with SSL termination and multi-host support.

Create a persistent volume backed by a disk, request storage with a persistent volume claim, and attach it to a MySQL pod in Kubernetes.

Learn how Kubernetes network policies control pod-to-pod communication within a cluster by defining ingress and egress rules, port selectors, and sources such as namespaces and IP blocks, separate from authentication.

Explore how Kubernetes gracefully shuts down ports by terminating unhealthy instances, using prestop hooks, and handling sigterm with a 30-second grace period to perform cleanup and close connections.

Explore Kubernetes scenarios like namespace isolation, service discovery via FQDN, and readiness probes. Learn rolling updates with max surge one and max unavailable zero, and implement network policies.

View failures as learning opportunities by analyzing what went wrong and seeking input from mentors or peers. Keep a journal of failures and lessons learned toward success.