Ultimate Google Cloud Certifications: All in one Bundle (4)

Please download attached file and go through LAB Exercise.

Lab Exercise is not tracked systematically and optional. Make sure you mark this lecture complete for your course completion certificate gets generated.

2.2 Planning and configuring compute resources. Considerations include:

• Selecting appropriate compute choices for a given workload (e.g., Compute Engine, Kubernetes Engine, App Engine).

• Using preemptible VMs and custom machine types as appropriate.

• 4.1 Managing Compute Engine resources. Tasks include:

  • Managing a single VM instance (e.g., start, stop, edit configuration, or delete an instance).

  • SSH/RDP to the instance.

  • Attaching a GPU to a new instance and installing CUDA libraries.

  • Viewing current running VM Inventory (instance IDs, details).

  • Working with snapshots (e.g., create a snapshot from a VM, view snapshots, delete a snapshot).

  • Working with Images (e.g., create an image from a VM or a snapshot, view images, delete an image).

  • Working with Instance Groups (e.g., set auto scaling parameters, assign instance template, create an instance template, remove instance group).

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, GCloud SDK).

• 4.2 Managing Kubernetes Engine resources. Tasks include:

  • Viewing current running cluster inventory (nodes, pods, services).

  • Browsing the container image repository and viewing container image details.

  • Working with nodes (e.g., add, edit, or remove a node).

  • Working with pods (e.g., add, edit, or remove pods).

  • Working with services (e.g., add, edit, or remove a service).

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, Cloud SDK).

• 4.3 Managing App Engine resources. Tasks include:

  • Adjusting application traffic splitting parameters.

  • Setting scaling parameters for autoscaling instances.

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, Cloud SDK).

• 4.4 Managing data solutions. Tasks include:

  • Executing queries to retrieve data from data instances (e.g., Cloud SQL, BigQuery, Cloud Spanner, Cloud Datastore, Cloud Bigtable, Cloud Dataproc).

  • Estimating costs of a BigQuery query.

  • Backing up and restoring data instances (e.g., Cloud SQL, Cloud Datastore, Cloud Dataproc).

  • Reviewing job status in Cloud Dataproc or BigQuery

  • Moving objects between Cloud Storage buckets.

  • Converting Cloud Storage buckets between storage classes.

  • Setting object lifecycle management policies for Cloud Storage buckets.

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, Cloud SDK).

• 4.5 Managing networking resources. Tasks include:

  • Adding a subnet to an existing VPC.

  • Expanding a CIDR block subnet to have more IP addresses.

  • Reserving static external or internal IP addresses.

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, Cloud SDK).

• 4.6 Monitoring and logging. Tasks include:

  • Creating Stackdriver alerts based on resource metrics.

  • Creating Stackdriver custom metrics.

  • Configuring log sinks to export logs to external systems (e.g., on premises or BigQuery).

  • Viewing and filtering logs in Stackdriver.

  • Viewing specific log message details in Stackdriver.

  • Using cloud diagnostics to research an application issue (e.g., viewing Cloud Trace data, using Cloud Debug to view an application point-in-time).

  • Viewing Google Cloud Platform status.

  • Working with management interfaces (e.g., Cloud Console, Cloud Shell, Cloud SDK).

5. Configuring access and security

• 
  

  5.1 Managing Identity and Access Management (IAM). Tasks include:

  • Viewing account IAM assignments.

  • Assigning IAM roles to accounts or Google Groups.

  • Defining custom IAM roles.

  5.2 Managing service accounts. Tasks include:

  • Managing service accounts with limited scopes.

  • Assigning a service account to VM instances.

  • Granting access to a service account in another project.

  5.3 Viewing audit logs for project and managed services.

• 5.1 Managing Identity and Access Management (IAM). Tasks include:

  • Viewing account IAM assignments.

  • Assigning IAM roles to accounts or Google Groups.

  • Defining custom IAM roles.

• 5.2 Managing service accounts. Tasks include:

  • Managing service accounts with limited scopes.

  • Assigning a service account to VM instances.

  • Granting access to a service account in another project.

• 1.1 Designing performant applications and APIs. Considerations include:

  • Infrastructure as a Service vs. Container as a Service vs. Platform as a Service (e.g., autoscaling implications)

  • Portability vs. platform-specific design

  • Evaluating different services and technologies

  • Operating system versions and base runtimes of services

  • Geographic distribution of Google Cloud services

  • Microservices

  • Defining a key structure for high write applications using Cloud Storage, Cloud Bigtable, Cloud Spanner, or Cloud SQL

  • Session management

  • Deploying and securing an API with cloud endpoints

  • Loosely coupled applications using asynchronous Cloud Pub/Sub events

  • Health checks

  • Google-recommended practices and documentation

• 1.2 Designing secure applications. Considerations include:

  • Applicable regulatory requirements and legislation

  • Security mechanisms that protect services and resources

  • Storing and rotating secrets

  • IAM roles for users/groups/service accounts

  • HTTPs certificates

  • Google-recommended practices and documentation

Already Covered as Part of Foundation.

1.3 Managing application data. Tasks include:

• • Defining database schemas for Google-managed databases (e.g., Cloud Datastore, Cloud Spanner, Cloud Bigtable, BigQuery)

  • Choosing data storage options based on use case considerations, such as:

    • Cloud Storage signed URLs for user-uploaded content

    • Using Cloud Storage to run a static website

    • Structured vs. unstructured data

    • ACID transactions vs. analytics processing

    • Data volume

    • Frequency of data access in Cloud Storage

  • Working with data ingestion systems (e.g., Cloud Pub/Sub, Storage Transfer Service)

  • Following Google-recommended practices and documentation

• 1.4 Re-architecting applications from local services to Google Cloud Platform. Tasks include:

  • Using managed services

  • Using the strangler pattern for migration

  • Google-recommended practices and documentation

• 2.1 Setting up your development environment. Considerations include:

  • Emulating GCP services for local application development

  • Creating GCP projects

• 2.2 Building a continuous integration pipeline. Considerations include:

  • Creating a Cloud Source Repository and committing code to it

  • Creating container images from code

  • Developing unit tests for all code written

  • Developing an integration pipeline using services (e.g., Cloud Build, Container Registry) to deploy the application to the target environment (e.g., development, test, staging)

  • Reviewing test results of continuous integration pipeline

• 2.3 Testing. Considerations include:

  • Performance testing

  • Integration testing

  • Load testing

• 2.4 Writing code. Considerations include:

  • Algorithm design

  • Modern application patterns

  • Efficiency

  • Agile methodology

• 3.1 Implementing appropriate deployment strategies based on the target compute environment (Compute Engine, Google Kubernetes Engine, App Engine). Strategies include:

  • Blue/green deployments

  • Traffic-splitting deployments

  • Rolling deployments

  • Canary deployments

• 3.2 Deploying applications and services on Compute Engine. Tasks include:

  • Launching a compute instance using GCP Console and Cloud SDK (gcloud) (e.g., assign disks, availability policy, SSH keys)

  • Moving a persistent disk to different VM

  • Creating an autoscaled managed instance group using an instance template

  • Generating/uploading a custom SSH key for instances

  • Configuring a VM for Stackdriver monitoring and logging

  • Creating an instance with a startup script that installs software

  • Creating custom metadata tags

  • Creating a load balancer for Compute Engine instances

• 3.3 Deploying applications and services on Google Kubernetes Engine. Tasks include:

  • Deploying a GKE cluster

  • Deploying a containerized application to GKE

  • Configuring GKE application monitoring and logging

  • Creating a load balancer for GKE instances

  • Building a container image using Cloud Build

• 3.4 Deploying an application to App Engine. Considerations include:

  • Scaling configuration

  • Versions

  • Traffic splitting

  • Blue/green deployment

• 3.7 Deploying and implementing networking resources. Tasks include:

  • Creating an auto mode VPC with subnets

  • Creating ingress and egress firewall rules for a VPC (e.g., IP subnets, Tags, Service accounts)

  • Setting up a domain using Cloud DNS

• 3.9 Managing Service accounts. Tasks include:

  • Creating a service account with a minimum number of scopes required

  • Downloading and using a service account private key file

• 4.1 Integrating an application with Data and Storage services. Tasks include:

  • Enabling BigQuery and setting permissions on a dataset

  • Writing an SQL query to retrieve data from relational databases

  • Analyzing data using BigQuery

  • Fetching data from various databases

  • Enabling Cloud SQL and configuring an instance

  • Connecting to a Cloud SQL instance

  • Enabling Cloud Spanner and configuring an instance

  • Creating an application that uses Cloud Spanner

  • Configuring a Cloud Pub/Sub push subscription to call an endpoint

  • Connecting to and running a CloudSQL query

  • Storing and retrieving objects from Google Storage

  • Publishing and consuming from Data Ingestion sources

  • Reading and updating an entity in a Cloud Datastore transaction from an application

  • Using the CLI tools

  • Provisioning and configuring networks

• 4.2 Integrating an application with Compute services. Tasks include:

  • Implementing service discovery in Google Kubernetes Engine, App Engine, and Compute Engine

  • Writing an application that publishes/consumes from Cloud Pub/Sub

  • Reading instance metadata to obtain application configuration

  • Authenticating users by using Oauth2 Web Flow and Identity Aware Proxy

  • Using the CLI tools

  • Configuring Compute services network settings (e.g., subnet, firewall ingress/egress, public/private IPs)

• 4.3 Integrating Google Cloud APIs with applications. Tasks include:

  • Enabling a GCP API

  • Using pre-trained Google ML APIs

  • Making API calls with a Cloud Client Library, the REST API, or the APIs Explorer, taking into consideration:

    • batching requests

    • restricting return data

    • paginating results

    • caching results

  • Using service accounts to make Google API calls

  • Using APIs to read/write to data services (BigQuery, Cloud Spanner)

  • Using the Cloud SDK to perform basic tasks

5.1 Installing the logging and monitoring agent

• 5.2 Managing VMs. Tasks include:

  • Debugging a custom VM image using the serial port

  • Analyzing a failed Compute Engine VM startup

  • Sending logs from a VM to Stackdriver

• 5.3 Viewing application performance metrics using Stackdriver. Tasks include:

  • Creating a monitoring dashboard

  • Viewing syslogs from a VM

  • Writing custom metrics and creating metrics from logs

  • Graphing metrics

  • Using Stackdriver Debugger

  • Streaming logs from the GCP Console

  • Reviewing stack traces for error analysis

  • Setting up log sinks

  • Viewing logs in the GCP Console

  • Profiling performance of request-response

  • Profiling services

  • Reviewing application performance using Stackdriver Trace and Stackdriver Logging

  • Monitoring and profiling a running application

• 5.4 Diagnosing and resolving application performance issues. Tasks include:

  • Setting up time checks and other basic alerts

  • Setting up logging and tracing

  • Setting up resources monitoring

  • Troubleshooting network issues

  • Debugging/tracing cloud apps

  • Troubleshooting issues with the image/OS

  • Using documentation, forums and Google support

• 1.1 Designing a solution infrastructure that meets business requirements. Considerations include:

  • business use cases and product strategy

  • cost optimization

  • supporting the application design

  • integration

  • movement of data

  • tradeoffs

  • build, buy or modify

  • success measurements (e.g., Key Performance Indicators (KPI), Return on Investment (ROI), metrics)

  • Compliance and observability

  • Provisioning one or more Stackdriver accounts.

• 1.2 Designing a solution infrastructure that meets technical requirements. Considerations include:

  • high availability and failover design

  • elasticity of cloud resources

  • scalability to meet growth requirements

• 1.3 Designing network, storage, and compute resources. Considerations include:

  • integration with on premises/multi-cloud environments

  • Cloud native networking (VPC, peering, firewalls, container networking)

  • identification of data processing pipeline

  • matching data characteristics to storage systems

  • data flow diagrams

  • storage system structure (e.g., Object, File, RDBMS, NoSQL, NewSQL)

  • mapping compute needs to platform products

• 1.4 Creating a migration plan (i.e., documents and architectural diagrams). Considerations include:

  • integrating solution with existing systems

  • migrating systems and data to support the solution

  • licensing mapping

  • network and management planning

  • testing and proof-of-concept

• 1.5 Envisioning future solution improvements. Considerations include:

  • cloud and technology improvements

  • business needs evolution

  • evangelism and advocacy

• 2.1 Configuring network topologies. Considerations include:

  • extending to on-premise (hybrid networking)

  • extending to a multi-cloud environment which may include GCP to GCP communication

  • security

  • data protection

• 2.2 Configuring individual storage systems. Considerations include:

  • data storage allocation

  • data processing/compute provisioning

  • security and access management

  • network configuration for data transfer and latency

  • data retention and data lifecycle management

  • data growth management

• 3.1 Designing for security. Considerations include:

  • Identity and Access Management (IAM)

  • Resource hierarchy (organizations, folders, projects)

  • data security (key management, encryption)

  • penetration testing

  • Separation of Duties (SoD)

  • security controls

  • Managing customer-supplied encryption keys with Cloud KMS

• 3.2 Designing for legal compliance. Considerations include:

  • legislation (e.g., Health Insurance Portability and Accountability Act (HIPAA), Children’s Online Privacy Protection Act (COPPA), etc.)

  • audits (including logs)

  • certification (e.g., Information Technology Infrastructure Library (ITIL) framework)

• 5.1 Advising development/operation team(s) to ensure successful deployment of the solution. Considerations include:

  • application development

  • API best practices

  • testing frameworks (load/unit/integration)

  • data and system migration tooling

• 5.2 Interacting with Google Cloud using GCP SDK (gcloud, gsutil and bq). Considerations include:

  • local installation

  • Google Cloud Shell

• 1.1 Selecting the appropriate storage technologies. Considerations include:

  • Mapping storage systems to business requirements

  • Data modeling

  • Tradeoffs involving latency, throughput, transactions

  • Distributed systems

  • Schema design

• 1.2 Designing data pipelines. Considerations include:

  • Data publishing and visualization (e.g., BigQuery)

  • Batch and streaming data (e.g., Cloud Dataflow, Cloud Dataproc, Apache Beam, Apache Spark and Hadoop ecosystem, Cloud Pub/Sub, Apache Kafka)

  • Online (interactive) vs. batch predictions

  • Job automation and orchestration (e.g., Cloud Composer)

• 1.3 Designing a data processing solution. Considerations include:

  • 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

• 1.4 Migrating data warehousing and data processing. Considerations include:

  • 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

• 2.1 Building and operationalizing storage systems. Considerations include:

  • effective use of managed services (Cloud Bigtable, Cloud Spanner, Cloud SQL, BigQuery, Cloud Storage, Cloud Datastore, Cloud Memorystore)

  • storage costs and performance

  • lifecycle management of data

• 2.2 Building and operationalizing pipelines. Considerations include:

  • data cleansing

  • batch and streaming

  • transformation

  • data acquisition and import

  • Integrating with new data sources

• 3.1 Leveraging pre-built ML models as a service. Considerations include:

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

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

  • conversational experiences (e.g., Dialogflow)

• 3.4 Measuring, monitoring, and troubleshooting machine learning models. Considerations include:

  • 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)

• 4.1 Designing for security and compliance. Considerations include:

  • identity and access management (e.g., Cloud IAM)

  • data security (encryption, key management)

  • ensuring privacy (e.g., Data Loss Prevention API)

  • legal compliance (e.g., Health Insurance Portability and Accountability Act (HIPAA), Children's Online Privacy Protection Act (COPPA), FedRAMP, General Data Protection Regulation (GDPR))

• 4.2 Ensuring scalability and efficiency. Considerations include:

  • building and running test suites

  • pipeline monitoring (e.g., Stackdriver)

  • assessing, troubleshooting, and improving data representations and data processing infrastructure

  • resizing and autoscaling resources

• 4.3 Ensuring reliability and fidelity. Considerations include:

  • performing data preparation and quality control (e.g., Cloud Dataprep)

  • verification and monitoring

  • planning, executing, and stress testing data recovery (fault tolerance, rerunning failed jobs, performing retrospective re-analysis)

  • choosing between ACID, idempotent, eventually consistent requirements

• 4.4 Ensuring flexibility and portability. Considerations include:

  • mapping to current and future business requirements

  • designing for data and application portability (e.g., multi-cloud, data residency requirements)

  • Data staging, cataloging and discovery

• 1.1 Designing the overall network architecture. Considerations include:

  • Failover and disaster recovery strategy

  • Options for high availability

  • DNS strategy (e.g., on-premises, Cloud DNS, GSLB)

  • Meeting business requirements

  • Choosing the appropriate load balancing options

  • Optimizing for latency (e.g., MTU size, caches, CDN)

  • Understanding how quotas are applied per project and per VPC

  • Hybrid connectivity (e.g., Google private access for hybrid connectivity)

  • Container networking

  • IAM and security

  • SaaS, PaaS, and IaaS services

  • Microsegmentation for security purposes (e.g., using metadata, tags)

• 1.3 Designing a hybrid network. Considerations include:

  • Using Interconnect (e.g., dedicated vs. partner)

  • Peering options (e.g., direct vs. carrier)

  • IPsec VPN

  • Cloud Router

  • Failover and disaster recovery strategy (e.g., building high availability with BGP using cloud router)

  • Shared vs. standalone VPC Interconnect access

  • Cross-organizational access

  • Bandwidth

• 2.1 Configuring VPCs. Considerations include:

  • Configuring GCP VPC resources (CIDR range, subnets, firewall rules, etc.)

  • Configuring VPC Peering

  • Creating a shared VPC and explaining how to share subnets with other projects

  • Configuring API access (Private, Public, NAT GW, Proxy)

  • Configuring VPC flow logs

• 2.2 Configuring routing. Tasks include:

  • Configuring internal static/dynamic routing

  • Configuring routing policies using tags and priority

  • Configuring NAT (e.g., CloudNAT, instance-based NAT)

• 2.3 Configuring and maintaining Google Kubernetes Engine clusters. Considerations include:

  • VPC-native Clusters using Alias IPs

  • Clusters with Shared VPC

  • Private Clusters

  • Cluster Network policy

  • Adding authorized networks for Cluster Master Access

• 2.4 Configuring and managing firewall rules. Considerations include:

  • Target network tags and service accounts

  • Priority

  • Network protocols

  • Ingress and egress rules

  • Firewall logs

• 3.1 Configuring load balancing. Considerations include:

  • Creating backend services

  • Firewall and security rules

  • HTTP(S) load balancer: including changing URL maps, backend groups, health checks, CDN, and SSL certs

  • TCP and SSL Proxy Load Balancers

  • Network load balancer

  • Internal load balancer

  • Session affinity

  • Capacity scaling

• 3.2 Configuring Cloud CDN. Considerations include:

  • Enabling and disabling Cloud CDN

  • Using cache keys

  • Cache invalidation

  • Signed URLs

• 3.3 Configuring and maintaining Cloud DNS. Considerations include:

  • Managing zones and records

  • Migrating to Cloud DNS

  • DNS Security (DNSSEC)

  • Global serving with Anycast

  • Cloud DNS

  • Internal DNS

  • Integrating on-premises DNS with GCP

• 3.4 Enabling other network services. Considerations include:

  • Health checks for your instance groups

  • Canary (A/B) releases

  • Distributing backend instances using regional managed instance groups

  • Enabling private API access

4.1 Configuring Interconnect. Considerations include:

• • Partner (e.g., Layer 2 vs. Layer 3 connectivity)

  • Virtualizing using Vlan attachments

  • Bulk storage uploads

  4.2 Configuring a site-to-site IPsec VPN (e.g., route-based, policy-based, dynamic or static routing).

  4.3 Configuring Cloud Router for reliability.

4.2 Configuring a site-to-site IPsec VPN (e.g., route-based, policy-based, dynamic or static routing).

• 5.1 Configuring Identity and Access Management (IAM). Tasks include:

  • Viewing account IAM assignments

  • Assigning IAM roles to accounts or Google Groups

  • Defining custom IAM roles

  • Using pre-defined IAM roles (e.g., network admin, network viewer, network user)

• 5.2 Configuring Cloud Armor policies. Considerations include:

  • IP-based access control

• 6.2 Managing and maintaining security. Considerations include:

  • Firewalls (e.g., cloud-based, private)

  • Diagnosing and resolving IAM issues (shared VPC, security/network admin)

• 6.3 Maintaining and troubleshooting connectivity issues. Considerations include:

  • Identifying traffic flow topology (e.g., load balancers, SSL offload, network endpoint groups)

  • Draining and redirecting traffic flows

  • Cross-connect handoff for Interconnect

  • Monitoring ingress and egress traffic using flow logs

  • Monitoring firewall logs

  • Managing and troubleshooting VPNs

  • Troubleshooting Cloud Router BGP peering issues

• 6.4 Monitoring, maintaining, and troubleshooting latency and traffic flow. Considerations include:

  • Network throughput and latency testing

  • Routing issues

  • Tracing traffic flow

• 7.1 Optimizing traffic flow. Considerations include:

  • Load balancer and CDN location

  • Global vs. Regional dynamic routing

  • Expanding subnet CIDR ranges in service

  • Accommodating workload increases (e.g., autoscaling vs. manual scaling)

• 7.2 Optimizing for cost and efficiency. Considerations include:

  • Cost optimization (Network Service Tiers, Cloud CDN, autoscaler (max instances))

  • Automation

  • VPN vs. Interconnect

  • Bandwidth utilization (e.g., kernel sys tuning parameters)