Google Cloud Certified Professional Cloud Developer Exam Guide: Modernize your applications using cloud-native services and best practices

✍ Scribed by Sebastian Moreno

• Publisher: Packt Publishing
• Tongue: English
• Leaves: 382
• Category: Library

✦ Synopsis

Discover how Google Cloud services can help you to reduce operational tasks and focus on delivering business value with your applications

Key Features

• Design, develop, and deploy end-to-end cloud-native applications using Google Cloud services
• Prepare for the GCP developer exam with the help of a fictitious business case and a Q&A section
• Get hands-on with implementing code examples of different GCP services in your applications

Book Description

Google Cloud Platform is one of the three major cloud providers in the industry, exhibiting great leadership in application modernization and data management. This book provides a comprehensive introduction for those who are new to cloud development and shows you how to use the tools to create cloud-native applications by integrating the technologies used by Google.

The book starts by taking you through the basic programming concepts and security fundamentals necessary for developing in Google Cloud. You'll then discover best practices for developing and deploying applications in the cloud using different components offered by Google Cloud Platform such as Cloud Functions, Google App Engine, Cloud Run, and other GCP technologies. As you advance, you'll learn the basics of cloud storage and choosing the best options for storing different kinds of data as well as understand what site reliability engineers do. In the last part, you'll work on a sample case study of Hip Local, a community application designed to facilitate communication between people nearby, created by the Google Cloud team.

By the end of this guide, you'll have learned how to design, develop, and deploy an end-to-end application on the Google Cloud Platform.

What you will learn

• Get to grips with the fundamentals of Google Cloud Platform development
• Discover security best practices for applications in the cloud
• Find ways to create and modernize legacy applications
• Understand how to manage data and databases in Google Cloud
• Explore best practices for site reliability engineering, monitoring, logging, and debugging
• Become well-versed with the practical implementation of GCP with the help of a case study

Who this book is for

This book is for cloud engineers or developers working or starting to work on Google Cloud Platform and looking to take advantage of cloud-native applications. You'll also find this book useful if you are preparing for the GCP developer exam.

Table of Contents

1. Google Cloud Platforms Developer Fundamentals
2. Security Fundamentals and Best Practices
3. Application Modernization using Google Cloud
4. Using Cloud Functions and Google App Engine
5. Virtual Machines and Container Applications on Google Cloud Platform
6. Managing APIs on Google Cloud Platform
7. Handling Unstructured Data
8. Databases and Event Messages in Google Cloud
9. Data Management and Databases Strategy
10. Optimizing Applications with Caching Strategies on Google Cloud Platform
11. Logging on Google Cloud Platform
12. Cloud Monitoring, Tracing, and Debugging
13. Hip Local Sample Case Study Preparation
14. Assessments

✦ Table of Contents

Cover
Title Page
Copyright and Credits
Contributors
Preface
Section 1: Welcome to the Google Cloud Developers Guide
Chapter 1: Google Cloud Platform Developer Fundamentals
Technical requirements
The basics that every developer should know about Google Cloud infrastructure
Regions and zones
What is X as a Service?
How to reduce latency to your end users
Graceful shutdowns
Top tips for developing and implementing resilient and scalable applications
Microservice ecosystems
Handling user sessions and the importance of stateless applications in the autoscaling world
Application logging, your best friend in error troubleshooting
Why should your microservices handle retries?
How to handle high traffic with autoscaling
Avoiding overload caching your data
Loosely coupled microservices with topics
Don't waste your time – use cloud management services and securely run your applications
Don't reinvent the wheel
Accessing services in a secure way
Summary
Chapter 2: Security Fundamentals and Best Practices
Technical requirements
Reducing the attack surface with POLP
POLP
How to authenticate client-to-service and service-to-service solutions
IAM
IAM hierarchy
Service accounts
Authenticating with Google services
OAuth 2.0
Identity-Aware Proxy
Managing secrets with Google Secret Manager
How to store your sensitive data in a secure way
Google Secret Manager
Cloud Key Management Service
Google Cloud best practices
POLP and roles
Create one service account per microservice
Avoid using Owner, Editor, and Viewer roles
allUsers versus allAuthenticatedUsers
Understand how the IAM hierarchy works
Use Google management keys whenever possible
Use OAuth 2.0 instead of sharing credentials between applications
Use IAP when possible to authenticate and authorize users inside your organization
Always use a key vault for the storage of secrets
Summary
Section 2: Developing and Modernizing Applications on Google Cloud Platform
Chapter 3: Application Modernization Using Google Cloud
Technical requirements
Preparing your environment for developing applications on Google Cloud
Emulating Google Cloud services for local application development
Creating Google Cloud projects
Using the command-line interface withCloud SDK
Using developer tooling
Be sure that your application will work fine on the cloud with testing
Unit testing
Integration testing
End-to-end testing
Load testing
Improving your delivery speed with continuous integration and delivery pipelines
Source control management
Creating secure container images from code
Application modernization best practices
Modern application design
Refactoring a monolith to microservices
Summary
Chapter 4: Using Cloud Functions and Google App Engine
Technical requirements
Welcome to serverless applications
What is serverless?
Advantages and disadvantages of serverless applications
Event-based applications
What is Google App Engine?
Introducing Google Cloud Functions
Different flavors for different situations
HTTP functions
Background functions
Triggering cloud functions from Cloud Storage
Triggering cloud functions from Pub/Sub
Triggering cloud functions from Firestore
Terminating HTTP functions
Terminating background cloud functions
App Engine standard environment
App Engine flexible environment
Exposing your services to the internet
Google App Engine invoked via HTTP
Cloud functions invoked via HTTP
Deployment and security considerations
Location considerations
Securing cloud functions
Securing App Engine
How to make a canary release strategy with A/B testing
Static versus dynamic data considerations
Using traffic splitting in App Engine
Summary
Chapter 5: Virtual Machines and Container Applications on Google Cloud Platform
Technical requirements
Introduction to Docker and Kubernetes
What is Docker?
What are containers and Docker container images?
What is Kubernetes?
Clusters, nodes, and pods in Kubernetes
How to use virtual machines on GCP
Google Compute Engine fundamentals
Managing service accounts for VMs
Bootstrapping applications
Managing Compute Engine VM images
Reading instance metadata to obtain application configuration
Forgetting the complexity of managing a Kubernetes cluster with GKE and Cloud Run
GKE fundamentals
Cloud Run fundamentals
Configuring Kubernetes namespaces
Pod life cycle and resource configuration
Managing Kubernetes RBAC and Google Cloud IAM relationships
The full deployment life cycle of an application on Google Compute Engine
Installing an application in a virtual machine
Creating an instance template
Creating a managed instance group
Configuring a load balancer
Hands-on tutorials in Google Compute Engine
The full deployment life cycle of an application on Google Kubernetes Engine and Cloud Run
Building a container image using Cloud Build
Defining workload specifications
Deploying a containerized application to GKE
Deploying a containerized application to Cloud Run
Hands-on tutorials in Cloud Run
Summary
Chapter 6: Managing APIs on Google Cloud Platform
Technical requirements
The basics before implementing an API management solution in Google Cloud
APIs
API management
The most common authentication methods
OpenAPI Specification
Swagger UI
Swagger Editor
How to protect your APIs using Cloud Endpoints on your deployments
ESP implementation for Cloud Endpoints
OpenAPI configuration for Cloud Endpoints
Discovering the enterprise API management world with Apigee
Deploying a serverless API using Cloud Functions
Implementing an API management solution with Apigee
Adding policies
Creating an API product
Creating a developer app
Securing and managing your serverless workloads with the new Cloud API Gateway
Deploying a serverless API using Cloud Functions
Creating an API in API Gateway
Exposing our service
Protecting our services
API development best practices
An overview of DDD
REST
Summary
Section 3: Storage Foundations
Chapter 7: Handling Unstructured Data
Technical requirements
Different real-world use cases for cloud storage
Worldwide delivery
Analytics
Backup
Disaster recovery
Audit
Optimizing costs regarding storage use cases
How to reduce costs using different tiers
Standard
Nearline
Coldline
Archive
Explaining storage pricing
Cloud storage summary diagrams
Backing up and deleting files automatically
Managing life cycles
Rule conditions
Implementing object life cycles
Object versioning
Bucket retention policy
Object hold protection
Protecting my data with security best practices
Access control
Data encryption
Signed URLs
Integrating cloud storage with my application
Storing and retrieving objects from cloud storage
How to avoid CORS problems
Summary
Chapter 8: Databases and Event Messages in Google Cloud
Technical requirements
First steps in the Cloud SQL and NoSQL world with Firestore
What is Cloud SQL?
Firestore
Differences in designing and integrating a SQL database versus a NoSQL database in your application
SQL versus NoSQL databases
Which database is better for my workload?
Traditional schema versus semi-structured database in Firestore
Understanding how to connect to a Cloud SQL instance and the Firestore dashboard
Creating and connecting to a Cloud SQL instance
Configuring a Firestore instance and viewing the Firestore dashboard
Decoupling applications using Pub/Sub
Pub/Sub types
Pub/Sub
Pub/Sub Lite
Relationship options
Publishing a message
Consuming a message using pull and push subscriptions
Creating, updating, and showing data in your frontend application
Firestore dependencies
Creating a document
Updating a document
Transactions
Batch writes
Getting a document from a collection
Getting a list of documents from a collection
Query cursors
Compound queries
Sub-collection queries
Deleting a document
Some points to remember when using Firestore
Summary
Chapter 9: Data Management and Database Strategies
Technical requirements
How to decide which database fits your needs
Cloud SQL
Cloud Spanner
Bigtable
Firestore
Choosing the right database
Data management strategies for your databases in Google Cloud
What is database sharding?
What is hot-spotting, and why should you avoid it?
Defining a key structure for high-write applications in Bigtable
Key design in Cloud Spanner
Defining keys for Firestore to avoid hot-spotting
Database and application management best practices
Keep your Cloud SQL small
Be prepared to fail
Improve the speed of your database to import data
Have a recovery plan
Optimize query execution in Cloud Spanner
Optimize bulk loading in Cloud Spanner
Optimize update operations in Cloud Spanner
Bigtable test best practices
Firestore location cases
Avoid hot-spotting due to read and write operations in collections
Reading and writing documents from Firestore
Reduce costs and remove limits with indexing exemption
Summary
Chapter 10: Optimizing Applications with Caching Strategies on Google Cloud Platform
Technical requirements
How, when, and why you should use a caching strategy in your applications
Why is having a cache strategy important?
When can we implement a cache strategy?
How can we implement a caching strategy?
Handling high traffic volumes with Memorystore for Memcached
Creating a Memcached instance
Connecting to a Memcached instance
Optimizing your application with Memorystore for Redis
Creating a Redis instance
Connecting to a Redis instance
Summary
Section 4: SRE for Developers
Chapter 11: Logging on Google Cloud Platform
Technical requirements
Introduction to Cloud Logging, the logging solution of GCP
Learning logging best practices in the cloud
Use libraries in your application to record logs
Don't create all logs on a single level
Categorize your logs correctly
Add meaningful descriptions
Make your logs understandable to both humans and machines
Add unique event IDs
Review your logging ingestion metrics
Exclude logs for cost optimization
How to enable an application to create custom logs
Enabling an app to create custom logs
Using Cloud Storage for cost optimization
Using Pub/Sub to trigger events
Using BigQuery for logs analysis
How to watch logs and make advanced logging queries on Cloud Logging
Our first search query
Advanced queries
Real-case logging examples using Cloud Logging and Cloud Monitoring
Centralization of multiple logs in a GCP project
Automatic error alerts
Summary
Chapter 12: Cloud Monitoring, Tracing, and Debugging
Technical requirements
Your first operational dashboard and metrics
Creating your first workspace
Creating your first dashboard
Monitoring your application uptime 24/7
Creating an uptime check
Finding bugs in your application with cloud debugging
Creating our base application
Using Cloud Debugger
Creating a snapshot
Creating a logpoint
Optimizing your application with cloud tracing and profiling
Cloud Trace
Cloud Profiler
Using Cloud Trace in our application
Using Cloud Profiler in our application
Real case examples using cloud monitoring, debugging, and tracing for applications on GCP
Cloud monitoring SLOs
Cloud Debugger in the cloud
Cloud Trace cases
Official documentation resources
Summary
Section 5: Analyzing a Sample Case Study
Chapter 13: HipLocal Sample Case Study Preparation
Technical requirements
Pro tips to ace the sample case study
Sample case structure
How to order the case information
Map services and technologies with Google Cloud
Reviewing the executive statement, existing solution, and requirements
Executive statement
Existing technical environment
Reviewing the technical requirements
Reviewing the business requirements
Architecting the solution
Summary
Chapter 14: Questions and Answers
Technical requirements
Questions
Google Cloud Platform (GCP) developer fundamentals
Security fundamentals and best practices
Application modernization using Google Cloud
Using Cloud Functions and GAE
Virtual machines (VMs) and container applications on GCP
Managing APIs on GCP
Handling unstructured data
Databases and event messages in Google Cloud
Data management and database strategy
Optimizing applications with caching strategies on GCP
Logging on GCP
Cloud monitoring, tracing, and debugging
Answers
GCP developer fundamentals
Security fundamentals and best practices
Application modernization using Google Cloud
Using Cloud Functions and GAE
VMs and container applications on GCP
Managing APIs on GCP
Handling unstructured data
Databases and event messages in Google Cloud
Data management and database strategy
Optimizing applications with caching strategies on GCP
Logging on GCP
Cloud monitoring, tracing, and debugging
Summary
Other Books You May Enjoy
Index