Extending to on-premises (hybrid networking)

Extending to a multi-cloud environment that may include GCP to GCP communication

Security and data protection

Data storage allocation

Data processing/compute provisioning

Security and access management

Network configuration for data transfer and latency

Data retention and data life cycle management

Data growth management

Compute system provisioning

Compute volatility configuration (preemptible vs. standard)

Network configuration for compute nodes

Identity and access management (IAM)

Resource hierarchy (organizations, folders, projects)

Data security (key management, encryption)

Penetration testing

Separation of duties (SoD)

Security controls (e.g., auditing, VPC Service Controls, organization policy)

Managing customer-managed encryption keys with Cloud KMS

Legislation (e.g., health record privacy, children’s privacy, data privacy, and ownership)

Commercial (e.g., sensitive data such as credit card information handling, personally identifiable information [PII])

Industry certifications (e.g., SOC 2)

Audits (including logs)

Software development life cycle plan (SDLC)

Continuous integration / continuous deployment

Troubleshooting / post mortem analysis culture

Testing and validation

Service catalogue and provisioning

Business continuity and disaster recovery

Stakeholder management (e.g. influencing and facilitation)

Change management

Team assessment / skills readiness

Decision-making process

Customer success management

Cost optimization / resource optimization (capex / opex)

Application development

API best practices

Testing frameworks (load/unit/integration)

Data and system migration tooling

Local installation

Google Cloud Shell

Immutable artifacts with Container Registry

Artifacts repositories with Container Registry

Deployment strategies with Cloud Build, Spinnaker

Deployment to hybrid and multi-cloud environments with Anthos, Spinnaker, Kubernetes

Artifacts versioning strategy with Cloud Build, Container Registry

CI/CD pipeline triggers with Cloud Source Repositories, Cloud Build GitHub App, Cloud Pub/Sub

Testing a new version with Spinnaker

Configure deployment processes (e.g., approval flows

CI with Cloud Build

CD with Cloud Build

Open source tooling (e.g. Jenkins, Spinnaker, Git Lab, Concourse)

Auditing and tracing of deployments (e.g., CSR, Cloud Build, Cloud Audit Logs)

Secure storage methods

Secret rotation and configuration changes

Terraform / Cloud Deployment Manager

Infrastructure code versioning

Make infrastructure changes safer

Immutable architecture

Centralized tools vs. multiple tools (single vs multi-tenant)

Security of CI/CD tooling

Decide on the number of environments and their purpose

Create environments dynamically per feature branch with GKE, Cloud Deployment Manager

Local development environments with Docker, Cloud Code, Scaffold

Vulnerability analysis with Container Registry

Binary Authorization

IAM policies per environment

Collecting logs from Compute Engine, GKE with Stackdriver Logging, Fluentd

Collecting third-party and structured logs with Stackdriver Logging, Fluentd

Sending application logs directly to Stackdriver API with Stackdriver Logging

Collecting metrics from Compute Engine

Collecting GKE/Kubernetes metrics

Use metric explorer for ad hoc metric analysis

Creating a monitoring dashboard

Filtering and sharing dashboards

Configure third-party alerting in Stackdriver Monitoring (i.e., Pager Duty, Slack, etc.)

Define alerting policies based on SLIs with Stackdriver Monitoring

Automate alerting policy definition with Cloud DM or Terraform

Implementing SLO monitoring and alerting with Stackdriver Monitoring

Understand Stackdriver Monitoring integrations (e.g., Grafana, BigQuery)

Using SIEM tools to analyze audit/flow logs (e.g., Splunk, Data dog)

Design Stackdriver Workspace strategy

Enabling data access logs (e.g., Cloud Audit Logs)

Enabling VPC flow logs

Viewing logs in the GCP Console

Using basic vs. advanced logging filters

Implementing logs-based metrics

Understanding the logging exclusion vs. logging export

Selecting the options for logging export

Implementing a project-level / org-level export

Viewing export logs in Cloud Storage and BigQuery

Sending logs to an external logging platform

Set ACL to restrict access to audit logs with IAM, Stack driver Logging

Set ACL to restrict export configuration with IAM, Stack driver Logging

Set ACL to allow metric writing for custom metrics with IAM, Stack driver Monitoring

Evaluate and understand user impact (Stackdriver Service Monitoring for App Engine, Istio)

Utilize Stackdriver to identify cloud resource utilization

Utilize Stackdriver Trace/Profiler to profile performance characteristics

Interpret service mesh telemetry

Troubleshoot issues with the image/OS

Troubleshoot network issues (e.g., VPC flow logs, firewall logs, latency, view network details)

Application instrumentation

Stackdriver Debugger

Stackdriver Logging

Stackdriver Trace

Debugging distributed applications

App Engine local development server

Stackdriver Error Reporting

Stackdriver Profiler

Identify resource costs

Identify resource utilization levels

Develop plan to optimize areas of greatest cost or lowest utilization

Manage pre-emptible VMs

Work with committed-use discounts

TCO considerations

Consider network pricing

Define roles (incident commander, communication lead, operations lead)

Handle requests for impact assessment

Provide regular status updates, internal and external

Record major changes in incident state (When mitigated When all clear etc.)

Establish communications channels (email, IRC, Hangouts, Slack, phone, etc.)

Scaling response team and delegation

Avoid exhaustion / burnout

Rotate / hand over roles

Manage stakeholder relationships

Identify probable causes of service failure

Evaluate symptoms against probable causes; rank probability of cause based on observed behavior

Perform investigation to isolate most likely actual cause

Identify alternatives to mitigate issue

Roll back release

Drain / redirect traffic

Turn off experiment

Add capacity

Code change / fix bug

Verify fix

Declare all-clear

Document root causes

Create and prioritize action items

Communicate post-mortem to stakeholders

MapReduce

Hadoop & HDFS

Apache Pig

Apache Spark

Apache Kafka

Pub/sub basics

pub/Sub Terminologies

Advanced Pub/Sub Concepts

Working with Pub/Sub

Introduction to Data flow

Pipeline Lifecycle

Dataflow pipeline concepts

Advanced Dataflow concepts

Dataflow security and access

Using Dataflow

Dataproc Basics

Working with Dataproc

Advanced Dataproc

Big Table Concepts

Big Table Architecture

Big Table Data Model

Big Table Schema Design

Big Table Advanced Concepts

BigQuery Basics

Using BigQuery

Partitioning and Clustering

Best Practices

Securing BigQuery

BigQuery Monitoring and Logging

Machine Learning with BigQuery ML

Working with BigQuery

Advanced BigQuery Concepts

Datalab Concepts

Working with Datalab

Reporting & Business intelligence

Data Distribution

Introduction to Cloud Data Studio

Charts and Filters

Orchestration with Cloud Composer

Cloud Composer Overview

Cloud Composer Architecture

Working with Cloud Composer

Advanced Cloud Composer Concepts

Choice of infrastructure

System availability and fault tolerance

Use of distributed systems

Capacity planning

Hybrid cloud and edge computing

Architecture options (e.g., message brokers, message queues, middleware, service-oriented architecture, serverless functions)

At least once, in-order, and exactly once, etc., event processing

Awareness of current state and how to migrate a design to a future state

Migrating from on-premises to cloud (Data Transfer Service, Transfer Appliance, Cloud Networking)

Validating a migration

Cloud Managed Services

Effectives Use of Managed Services

Storage Cost and performance

Lifecycle Management of Data

Data cleansing

Batch and streaming

Transformation

Data acquisition and import

Integrating with new data sources

Provisioning resources

Monitoring pipelines

Adjusting pipelines

Testing and quality control

Machine Learning Introduction

Machine Learning Basics

Machine Learning Types and Models

Overfitting

Hyperparameters

Feature Engineering

Deep Learning with TensorFlow

Introduction to Artificial Neural Networks

Neural Network Architectures

Building a Neural Network

ML APIs (e.g., Vision API, Speech API)

Customizing ML APIs (e.g., AutoML Vision, Auto ML text)

Conversational experiences (e.g., Dialogflow)

Ingesting appropriate data

Retraining of machine learning models (Cloud Machine Learning Engine, BigQuery ML, Kubeflow, Spark ML)

Continuous evaluation

Distributed vs. single machine

Use of edge compute

Hardware accelerators (e.g., GPU, TPU)

Machine learning terminology (e.g., features, labels, models, regression, classification, recommendation, supervised and unsupervised learning, evaluation metrics)

Impact of dependencies of machine learning models

Common sources of error (e.g., assumptions about data)