GCPDNPS - Architecting with Google Cloud: Design and Process
This course features a combination of lectures, design activities, and hands-on labs to show you how to use proven design patterns on Google Cloud to build highly reliable and efficient solutions and operate deployments that are highly available and cost-effective. This course was created for those who have already completed the Architecting with Google Compute Engine or Architecting with Google Kubernetes Engine course.
This course teaches participants the following skills:
- Apply a tool set of questions, techniques and design considerations ?Define application requirements and express them objectively as KPIs, SLO's and SLI's
- Decompose application requirements to find the right microservice boundaries
- Leverage Google Cloud developer tools to set up modern, automated deployment pipelines
- Choose the appropriate Google Cloud Storage services based on application requirements
- Architect cloud and hybrid networks
- Implement reliable, scalable, resilient applications balancing key performance metrics with cost
- Choose the right Google Cloud deployment services for your applications ?Secure cloud applications, data and infrastructure
- Monitor service level objectives and costs using Stackdriver tools
- Cloud Solutions Architects, Site Reliability Engineers, Systems Operations professionals, DevOps Engineers, IT managers.
- Individuals using Google Cloud Platform to create new solutions or to integrate existing systems, application environments, and infrastructure with the Google Cloud Platform.
The course includes presentations, demonstrations, and hands-on labs.
Module 1: Defining the Service
Module 2: Microservice Design and Architecture
- Describe users in terms of roles and personas.
- Write qualitative requirements with user stories.
- Write quantitative requirements using key performance indicators (KPIs).
- Evaluate KPIs using SLOs and SLIs.
- Determine the quality of application requirements using SMART criteria.
Module 3: DevOps Automation
- Decompose monolithic applications into microservices.
- Recognize appropriate microservice boundaries.
- Architect stateful and stateless services to optimize scalability and reliability.
- Implement services using 12-factor best practices.
- Build loosely coupled services by implementing a well-designed REST architecture.
- Design consistent, standard RESTful service APIs.
Module 4: Choosing Storage Solutions
- Automate service deployment using CI/CD pipelines.
- Leverage Cloud Source Repositories for source and version control.
- Automate builds with Cloud Build and build triggers.
- Manage container images with Google Container Registry.
- Create infrastructure with code using Deployment Manager and Terraform.
Module 5: Google Cloud and Hybrid Network Architecture
- Choose the appropriate Google Cloud data storage service based on use case, durability, availability, scalability and cost.
- Store binary data with Cloud Storage.
- Store relational data using Cloud SQL and Spanner.
- Store NoSQL data using Firestore and Cloud Bigtable.
- Cache data for fast access using Memorystore.
- Build a data warehouse using BigQuery.
Module 6: Deploying Applications to Google Cloud
- Design VPC networks to optimize for cost, security, and performance.
- Configure global and regional load balancers to provide access to services.
- Leverage Cloud CDN to provide lower latency and decrease network egress.
- Evaluate network architecture using the Cloud Network Intelligence Center.
- Connect networks using peering and VPNs.
- Create hybrid networks between Google Cloud and on-premises data centers using Cloud Interconnect.
Module 7: Designing Reliable Systems
- Choose the appropriate Google Cloud deployment service for your applications.
- Configure scalable, resilient infrastructure using Instance Templates and Groups.
- Orchestrate microservice deployments using Kubernetes and GKE.
- Leverage App Engine for a completely automated platform as a service (PaaS).
- Create serverless applications using Cloud Functions.
Module 8: Security
- Design services to meet requirements for availability, durability, and scalability.
- Implement fault-tolerant systems by avoiding single points of failure, correlated failures, and cascading failures.
- Avoid overload failures with the circuit breaker and truncated exponential backoff design patterns.
- Design resilient data storage with lazy deletion.
- Analyze disaster scenarios and plan for disaster recovery using cost/risk analysis.
Module 9: Maintenance and Monitoring
- Design secure systems using best practices like separation of concerns, principle of least privilege, and regular audits.
- Leverage Cloud Security Command Center to help identify vulnerabilities.
- Simplify cloud governance using organizational policies and folders.
- Secure people using IAM roles, Identity-Aware Proxy, and Identity Platform.
- Manage the access and authorization of resources by machines and processes using service accounts.
- Secure networks with private IPs, firewalls, and Private Google Access.
- Mitigate DDoS attacks by leveraging Cloud DNS and Cloud Armor.
- Manage new service versions using rolling updates, blue/green deployments, and canary releases.
- Forecast, monitor, and optimize service cost using the Google Cloud pricing calculator and billing reports and by analyzing billing data.
- Observe whether your services are meeting their SLOs using Cloud Monitoring and Dashboards.
- Use Uptime Checks to determine service availability.
- Respond to service outages using Cloud Monitoring Alerts
To get the most out of this course, participants should have:
- Have completed Architecting with Google Compute Engine, Architecting with Google Kubernetes Engine, or have equivalent experience
- Have basic proficiency with command-line tools
- Have systems operations experience, including deploying and managing applications, either on-premises or in a public cloud environment
This course is not associated with any Certification.