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

Length: 382 pages
Edition: 1
Language: English
Publisher: Packt Publishing
Publication Date: 2021-09-13
ISBN-10: 1800560990
ISBN-13: 9781800560994
Sales Rank: #319670 (See Top 100 Books)

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.

Google Cloud Platforms Developer Fundamentals
Security Fundamentals and Best Practices
Application Modernization using Google Cloud
Using Cloud Functions and Google App Engine
Virtual Machines and Container Applications on Google Cloud Platform
Managing APIs on Google Cloud Platform
Handling Unstructured Data
Databases and Event Messages in Google Cloud
Data Management and Databases Strategy
Optimizing Applications with Caching Strategies on Google Cloud Platform
Logging on Google Cloud Platform
Cloud Monitoring, Tracing, and Debugging
Hip Local Sample Case Study Preparation
Assessments

Google Cloud Certified Professional Cloud Developer Exam Guide
Contributors
About the author
About the reviewer
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share Your Thoughts
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
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share Your Thoughts

Donate to keep this site alive

To access the Link, solve the captcha.

How to download source code?

1. Go to: https://github.com/PacktPublishing

2. In the Find a repository… box, search the book title: Google Cloud Certified Professional Cloud Developer Exam Guide: Modernize your applications using cloud-native services and best practices, sometime you may not get the results, please search the main title.