Professional Cloud Developer
Professional Cloud Developer
Intermediate
Gauge your current knowledge
Intermediate
Gauge your current knowledge
Building, refactoring, and deploying application containers to Cloud Run and GKE
...
Professional Cloud Developer
Gauge your current knowledge
Gauge your current knowledge
Cloud Run is a fully managed serverless platform for running containerized applications. It is designed for stateless applications that respond to web requests or events, allowing developers to focus on code while Google Cloud manages the infrastructure. A key benefit is advanced Autoscaling, which can scale container instances up to handle traffic spikes and even down to zero when there is no demand, optimizing costs.
You can fine-tune performance by configuring settings like Concurrency, which controls how many simultaneous requests a single container instance handles. Setting Minimum Instances keeps containers warm to prevent slow cold starts, and CPU Boost provides extra power during container startup to reduce latency. Each deployment creates an immutable Revision. Using Traffic Splitting, you can direct a specific percentage of incoming traffic to different revisions, enabling strategies like Canary Releases (sending a small amount of traffic to test a new version) or Blue-Green Deployments (instantly switching all traffic once a new version is verified).
For security, Binary Authorization ensures only trusted and verified container images are deployed. You can use VPC Service Controls to create secure network perimeters, and each service uses a Service Account to authenticate with other Google Cloud resources like databases. While GKE offers more control for complex workloads, Cloud Run is preferred for its simplicity. Both use standard containers, providing high Portability and enabling a hybrid architecture where you choose the best runtime for each microservice.
Containerization packages an application and its dependencies into a portable container image. This process is key to modernizing applications by refactoring monolithic systems into smaller, independent microservices, often guided by Twelve-Factor App principles. These containerized applications can then be deployed to platforms like Google Kubernetes Engine (GKE) or Cloud Run for better scalability and reliability.
Managing these images centrally is done with Artifact Registry, a secure repository for storing and versioning container images. The build process is often automated with Cloud Build, which produces new artifacts whenever code changes. Using trusted base images and Semantic Versioning for labels ensures builds are consistent, repeatable, and easy to track. Choosing between Cloud Run and GKE depends on the application: Cloud Run is a serverless platform ideal for stateless services that need automatic scaling, while GKE provides full control over Kubernetes clusters and is better for complex microservices or applications needing persistent storage.
Automated CI/CD pipelines accelerate software delivery and reduce errors. Tools like Cloud Deploy manage the continuous delivery of images across environments like staging and production. These pipelines integrate stages for code review, continuous integration (automated building and testing), and continuous delivery. Security is integrated early; Artifact Analysis scans images for vulnerabilities before deployment, and Binary Authorization acts as a final gatekeeper, ensuring only trusted, verified images can run in the production environment.
Google Kubernetes Engine (GKE) is a managed service for orchestrating containerized applications at scale. The basic deployable unit is a Pod, which holds one or more containers. A critical first decision is choosing the cluster mode: Autopilot, where Google manages the nodes, or Standard, where you have more control. Kubernetes uses a declarative model, meaning you define the desired state of your application in YAML files called Manifests.
These manifests specify resource requirements like CPU and memory limits for each container. Defining these limits prevents any single workload from consuming all cluster resources and ensures predictable performance. To handle changing demand, GKE offers automated scaling. The Horizontal Pod Autoscaler (HPA) adjusts the number of Pod replicas based on metrics like CPU utilization. If the cluster needs more capacity to host these new Pods, the Cluster Autoscaler can automatically add more nodes.
Networking within GKE is managed through Kubernetes objects. A Service provides a stable network endpoint for a dynamic set of Pods. For external access, you use Ingress, which provides advanced routing and SSL termination. Key service types include ClusterIP for internal communication, LoadBalancer to expose a service directly to the internet, and Ingress for sophisticated, multi-service routing rules. Configuring these components ensures your applications are both reachable and secure.
Deploying to GKE effectively requires a robust CI/CD pipeline. Developers build container images and push them to Artifact Registry. Tools like Cloud Build automate the build process, and Cloud Deploy can manage the progressive rollout of these immutable artifacts to the GKE cluster. This automated flow from code to production reduces configuration drift and ensures that what was tested is exactly what gets deployed.