Complete Google Cloud Platform (GCP) Tutorial - GUI Version

1. What is Google Cloud Platform (GCP)?

Google Cloud Platform (GCP) is a suite of cloud computing services that runs on the same infrastructure Google uses internally for its end-user products, such as Google Search, Gmail, YouTube, and Google Maps. It offers a wide range of modular cloud services for computing, data storage, data analytics, machine learning, and application development.

GCP provides businesses and developers with flexible, secure, and highly scalable cloud resources to build, deploy, and manage applications and services.

Key Advantages of Cloud Computing (GCP):

• Global Scale: Leverage Google's global network and data centers.
• Innovation: Access to cutting-edge technologies like AI/ML, Big Data, and serverless computing.
• Open Source Friendly: Strong support for open-source technologies (e.g., Kubernetes).
• Cost-Effectiveness: Per-second billing for many services, sustained use discounts, and committed use discounts.
• Security: Benefit from Google's deep expertise in security and global infrastructure.
• Carbon Neutral: Google Cloud operates on 100% renewable energy.

2. GCP Global Infrastructure

GCP's infrastructure is built for high performance, reliability, and global reach.

• Regions: Independent geographic areas consisting of multiple zones. Each region is isolated from other regions. Examples: `us-central1` (Iowa), `europe-west1` (Belgium), `asia-southeast1` (Singapore).
• Zones: Distinct physical locations within a region. Each zone has independent power, cooling, and networking, designed to be isolated from failures in other zones within the same region. They are connected by low-latency networks.
• Global Network: Google's private global network provides fast, secure, and low-latency connectivity between regions and zones.
• Edge Locations: Points of presence (PoPs) closer to end-users globally, used by services like Cloud CDN for content caching.

3. Getting Started with GCP

A. Create a Google Cloud Account:

Go to cloud.google.com/free/ to sign up for a free Google Cloud account. New customers typically receive $300 in free credits to explore any GCP product for 90 days, along with free usage limits for certain products beyond the trial period.

B. The Google Cloud Console:

This is the web-based graphical user interface (GUI) for managing your GCP projects and resources. It allows you to create, configure, monitor, and delete services. This tutorial will focus on using the Console.

# Access: console.cloud.google.com

Upon logging in, you'll see the **Dashboard**, providing an overview of your active projects, resources, and billing information.

4. Resource Hierarchy & IAM

GCP organizes your resources hierarchically, and Identity and Access Management (IAM) controls who has what access to these resources.

• Organization: The root node in the GCP resource hierarchy, representing your company. (If you have a G Suite/Cloud Identity domain).
• Folders: Group projects under an organization, allowing for easier management and policy application.
• Projects: The base container for all your GCP resources. All resources (VMs, databases, storage buckets) must belong to a project. Each project has a unique ID and number.
• Resources: The actual GCP services (e.g., Compute Engine instances, Cloud Storage buckets).

Cloud IAM (Identity and Access Management) - GUI Usage:

Cloud IAM is accessed via the **IAM & Admin** section in the Cloud Console navigation menu.

1. Navigate to IAM:

   Google Cloud Console > Navigation menu (☰) > IAM & Admin > IAM

2. Granting Permissions:
   • Click **+ GRANT ACCESS**.
   • In the "New principals" field, enter the email address of the user (Google Account), service account, or Google Group you want to grant access to.
   • In the "Select a role" dropdown, search for and select the desired role (e.g., `Compute Admin`, `Storage Object Viewer`).
   • Click **SAVE**.
3. Creating a Service Account:
   • Go to:

     Google Cloud Console > Navigation menu (☰) > IAM & Admin > Service Accounts

   • Click **+ CREATE SERVICE ACCOUNT**.
   • Provide a Service account name, ID (auto-generated), and optional description. Click **CREATE AND CONTINUE**.
   • In "Grant this service account access to project," select the desired roles. Click **CONTINUE**.
   • (Optional) Grant users access to this service account. Click **DONE**.
   • To create a key for the service account (e.g., JSON key for application authentication):
     • Click the newly created service account.
     • Go to the **KEYS** tab.
     • Click **ADD KEY > Create new key**.
     • Select **JSON** as the key type and click **CREATE**. The JSON key file will download. Store it securely.

5. Compute Services

GCP offers various compute options, from virtual machines to serverless functions.

A. Compute Engine (IaaS - Infrastructure as a Service) - GUI Usage:

Provides customizable virtual machines (VMs) running on Google's infrastructure.

1. Navigate to Compute Engine:

   Google Cloud Console > Navigation menu (☰) > Compute Engine > VM instances

2. Create a VM instance:
   • Click **+ CREATE INSTANCE**.
   • Name: Provide a unique name (e.g., `my-first-gcp-vm`).
   • Region & Zone: Select a region (e.g., `us-central1`) and a zone (e.g., `us-central1-a`).
   • Machine configuration: Choose a Series and Machine type (e.g., `E2 series`, `e2-micro` for Free Tier eligibility).
   • Boot disk: Click **CHANGE** to select your OS (e.g., `Debian GNU/Linux 11 (bullseye)`). Keep default boot disk size for `e2-micro` (10 GB Standard persistent disk).
   • Firewall: Check **Allow HTTP traffic** and **Allow HTTPS traffic** (if you plan to run a web server).
   • Management, security, disks, networking, sole tenancy: (Optional sections for advanced configuration). For adding a startup script:
     • Click **Management**.
     • Under "Automation," paste your startup script into the "Startup script" field.

       #!/bin/bash
       sudo apt update
       sudo apt install -y nginx
       sudo systemctl start nginx
       sudo systemctl enable nginx

   • Click **CREATE**.
3. Accessing the VM:
   • Once the VM is running, its external IP address will be listed on the "VM instances" page.
   • To SSH into the VM, click the **SSH** button next to your instance name. This opens a browser-based SSH session.
   • If you installed Nginx via the startup script, you can access the web server by navigating to the VM's external IP address in your browser.

B. App Engine (PaaS - Platform as a Service) - GUI Usage:

Fully managed platform for building and deploying scalable web applications and mobile backends.

1. Navigate to App Engine:

   Google Cloud Console > Navigation menu (☰) > App Engine > Dashboard

   If this is your first time, you may need to click "CREATE APPLICATION" and select a region.

2. Deploy an App Engine App:
   • You'll typically deploy code from a local directory or a source repository. For this GUI tutorial, we'll outline the steps if you were deploying a simple app like the Node.js example from the CLI tutorial.
   • Prepare your `app.js` and `app.yaml` files locally (as shown in the CLI section).
   • In the Console, you can use the **Cloud Shell** (pre-installed with `gcloud`) to deploy, which is the most common method even for GUI users:
     • Open Cloud Shell (icon in top right of Console).
     • Upload your `app.js` and `app.yaml` files to Cloud Shell.
     • Run `gcloud app deploy` from within Cloud Shell.
   • Alternatively, for some runtimes, you can click **CREATE APPLICATION** or **DEPLOY A VERSION** and follow the prompts to connect to a source repository.
3. Accessing the App: Once deployed, the App Engine Dashboard will show your application's URL.

C. Cloud Functions (FaaS - Functions as a Service) - GUI Usage:

Event-driven serverless compute service.

1. Navigate to Cloud Functions:

   Google Cloud Console > Navigation menu (☰) > Cloud Functions

2. Create a Function:
   • Click **+ CREATE FUNCTION**.
   • **Environment:** Select `2nd generation` (recommended for new functions) or `1st generation`.
   • **Function name:** (e.g., `hello-http-gui`).
   • **Region:** (e.g., `us-central1`).
   • **Trigger type:** Select `HTTP`. Check "Require authentication" if needed, otherwise leave unchecked for public access.
   • **Runtime:** Select `Python 3.9` (or desired runtime).
   • **Entry point:** `hello_http` (or the name of your function in the code).
   • In the "Source code" editor, replace the default code with your `hello_http` function (as shown in the CLI tutorial for Python).
   • Click **DEPLOY**.
3. Testing the Function:
   • Once deployed, click on your function name in the list.
   • Go to the **TESTING** tab.
   • Under "Triggering event," you can use "Test the function." Click **TEST THE FUNCTION** button. The "Output" pane will show "Hello World!".
   • Alternatively, use the "Triggering URL" from the "Trigger" tab to access it via browser or `curl`.

D. Google Kubernetes Engine (GKE) - GUI Usage:

A managed environment for deploying, managing, and scaling containerized applications using Kubernetes.

1. Navigate to GKE:

   Google Cloud Console > Navigation menu (☰) > Kubernetes Engine > Clusters

2. Create a Cluster:
   • Click **+ CREATE CLUSTER**.
   • Choose a "Standard" or "Autopilot" cluster. (Autopilot simplifies management).
   • Provide a **Name** for your cluster.
   • Select **Region** or **Zone**.
   • Configure other options as needed (e.g., node pools, networking).
   • Click **CREATE**.
3. Deploying to GKE: After the cluster is created, you use `kubectl` (from Cloud Shell or locally) to deploy your containerized applications.

E. Cloud Run - GUI Usage:

Fully managed serverless platform for running containerized applications.

1. Navigate to Cloud Run:

   Google Cloud Console > Navigation menu (☰) (or search for Cloud Run) > Cloud Run

2. Create a Service:
   • Click **+ CREATE SERVICE**.
   • Select "Deploy a new revision from an existing container image". (You'd need to push a Docker image to Google Container Registry or Artifact Registry first, e.g., `gcr.io/cloudrun/hello`).
   • Provide a **Service name**.
   • Select a **Region**.
   • **Authentication:** Choose "Allow unauthenticated invocations" for public access.
   • Click **CREATE**.
3. Testing: Once deployed, the service URL will be provided.

6. Storage Services

GCP offers a variety of storage options for different data types and access patterns.

A. Cloud Storage (Object Storage) - GUI Usage:

Scalable, highly durable, and cost-effective object storage for unstructured data.

1. Navigate to Cloud Storage:

   Google Cloud Console > Navigation menu (☰) > Cloud Storage > Buckets

2. Create a Bucket:
   • Click **+ CREATE BUCKET**.
   • Name your bucket: Must be globally unique (e.g., `my-unique-gcp-bucket-2025-july-gui`). Click **CONTINUE**.
   • Choose where to store your data: Select a **Location type** (e.g., `Region`) and a **Location** (e.g., `us-central1`). Click **CONTINUE**.
   • Choose a default storage class for your data: Select an option (e.g., `Standard`). Click **CONTINUE**.
   • Choose how to control access to objects: Select your preferred access control (e.g., `Uniform` for simpler management). Click **CONTINUE**.
   • (Optional) Configure data protection (versioning, soft delete) and encryption.
   • Click **CREATE**.
3. Upload a File:
   • Click on your newly created bucket name.
   • Click **UPLOAD FILES**.
   • Select a file from your computer to upload.
4. Manage/Delete Files: On the bucket details page, you can see your uploaded files, download them, or delete them. To delete the bucket, it must be empty first.

B. Persistent Disk (Block Storage) - GUI Usage:

Durable, high-performance block storage for Compute Engine VMs.

1. Navigate to Persistent Disks:

   Google Cloud Console > Navigation menu (☰) > Compute Engine > Disks

2. Create a Disk:
   • Click **+ CREATE DISK**.
   • **Name:** (e.g., `my-data-disk`).
   • **Zone:** Same zone as the VM you'll attach it to.
   • **Disk type:** (e.g., `Balanced persistent disk` or `Standard persistent disk`).
   • **Size:** (e.g., `50 GB`).
   • Click **CREATE**.
3. Attach to VM: After creation, click on the disk name, then **ATTACH TO VM**. Select your desired VM instance.

C. Filestore (Managed NFS) - GUI Usage:

Fully managed, high-performance file storage.

1. Navigate to Filestore:

   Google Cloud Console > Navigation menu (☰) > Filestore > Instances

2. Create Instance:
   • Click **+ CREATE INSTANCE**.
   • Choose an **Instance tier** (e.g., `Basic HDD`).
   • Provide an **Instance name** and **File share name**.
   • Configure **Region** and **Zone**.
   • **Allocated capacity:** (e.g., `1 TB`).
   • **VPC network:** Select the VPC network your clients will use.
   • Click **CREATE**.

7. Networking Services

GCP provides a robust set of networking capabilities built on Google's global private network.

A. Virtual Private Cloud (VPC) - GUI Usage:

A global, software-defined network for your GCP resources.

1. Navigate to VPC networks:

   Google Cloud Console > Navigation menu (☰) > VPC network > VPC networks

2. Create a VPC network:
   • Click **+ CREATE VPC NETWORK**.
   • **Name:** (e.g., `my-gui-vpc`).
   • Subnet creation mode: Choose `Custom`.
   • Click **ADD SUBNET**:
     • Name: (e.g., `my-gui-subnet`).
     • Region: (e.g., `us-central1`).
     • IP address range: (e.g., `10.10.0.0/24`).
     • Click **DONE**.
   • **Firewall rules:** Select predefined rules like `Allow http traffic` and `Allow https traffic` and `Allow ssh`.
   • Click **CREATE**.
3. Firewall Rules (manual creation):
   • Go to:

     VPC network > Firewall

   • Click **+ CREATE FIREWALL RULE**.
   • Configure name, network, direction, action, protocols and ports, source/destination.
   • Click **CREATE**.

B. Cloud Load Balancing - GUI Usage:

High-performance, scalable load balancing.

1. Navigate to Load balancing:

   Google Cloud Console > Navigation menu (☰) > Network services > Load balancing

2. Create a Load Balancer:
   • Click **+ CREATE LOAD BALANCER**.
   • Choose a load balancer type (e.g., "HTTP(S) Load Balancing" for web apps).
   • Select "From Internet to my VMs" (External Load Balancer).
   • Configure frontend, backend, and routing rules.
   • Click **CREATE**.

C. Cloud DNS - GUI Usage:

A scalable, reliable, and managed authoritative DNS service.

1. Navigate to Cloud DNS:

   Google Cloud Console > Navigation menu (☰) > Network services > Cloud DNS

2. Create Zone:
   • Click **+ CREATE ZONE**.
   • Choose "Public zone" or "Private zone".
   • Provide a **Zone name** and **DNS name** (your domain, e.g., `example.com`).
   • Click **CREATE**.
3. Add Records: In your zone, click **ADD STANDARD RECORD SET** to add A, CNAME, MX, etc., records.

8. Database Services

GCP offers a comprehensive portfolio of managed database services.

A. Cloud SQL (Managed Relational Database) - GUI Usage:

Fully managed relational database service for MySQL, PostgreSQL, and SQL Server.

1. Navigate to Cloud SQL:

   Google Cloud Console > Navigation menu (☰) > Databases > Cloud SQL

2. Create Instance:
   • Click **+ CREATE INSTANCE**.
   • Choose your database engine (e.g., `Choose MySQL`).
   • **Instance ID:** (e.g., `my-gcp-sql-instance-gui`).
   • **Password:** Set a strong password for the root/default user.
   • **Region:** (e.g., `us-central1`).
   • **Database version:** Select.
   • (Optional) Expand "Show configuration options" to set machine type, storage, high availability.
   • Click **CREATE INSTANCE**.
3. Connect to the instance:
   • Once created, click on the instance name.
   • Go to the **Connections** tab.
   • Under "Public IP address," click **ADD A NETWORK** to authorize your current public IP address for testing (or configure Cloud SQL Auth Proxy for secure connections).

B. Firestore (Serverless NoSQL Document Database) - GUI Usage:

A flexible, scalable NoSQL cloud database.

1. Navigate to Firestore:

   Google Cloud Console > Navigation menu (☰) > Databases > Firestore

2. Choose Mode: Select "Native Mode" (recommended) or "Datastore mode".
3. Create Database: Select a **Location** and click **CREATE DATABASE**.
4. Add Data: Once created, go to the **Data** tab to manually add collections and documents.

C. Cloud Bigtable (NoSQL Wide-Column Database) - GUI Usage:

A fully managed, scalable NoSQL database service for large analytical and operational workloads.

1. Navigate to Bigtable:

   Google Cloud Console > Navigation menu (☰) > Databases > Bigtable

2. Create Instance:
   • Click **+ CREATE INSTANCE**.
   • **Instance ID:** (e.g., `my-bigtable-instance`).
   • **Instance type:** (e.g., `Development` for testing, `Production` for higher scale).
   • **Region & Zone:** Select.
   • Click **CREATE**.

9. Security & Identity

GCP offers robust security services to protect your data and applications.

A. Cloud IAM (Identity and Access Management) - GUI Usage:

(Already covered in Section 4)

B. Cloud Key Management Service (Cloud KMS) - GUI Usage:

A cloud-hosted key management service.

1. Navigate to Key Management:

   Google Cloud Console > Navigation menu (☰) > Security > Key Management

2. Create Key Ring & Key:
   • Click **+ CREATE KEY RING**.
   • **Name:** (e.g., `my-app-keys`).
   • **Location:** Select. Click **CREATE**.
   • Within the Key Ring, click **+ CREATE KEY**.
   • **Name:** (e.g., `my-encryption-key`).
   • **Protection level:** (e.g., `Software`).
   • **Purpose:** (e.g., `Symmetric encrypt/decrypt`). Click **CREATE**.

C. Security Command Center - GUI Usage:

A centralized security and risk management platform for GCP.

1. Navigate to Security Command Center:

   Google Cloud Console > Navigation menu (☰) > Security > Security Command Center

2. Enable and Explore: Follow the prompts to enable Security Command Center for your organization or project. Explore the dashboard for findings, assets, and vulnerabilities.

10. Management & Governance

Services to help you manage, monitor, and govern your GCP environment efficiently.

A. Cloud Monitoring - GUI Usage:

Monitors performance, uptime, and health of resources.

1. Navigate to Monitoring:

   Google Cloud Console > Navigation menu (☰) > Monitoring > Dashboards

2. Explore Dashboards: View pre-built dashboards for various services (e.g., "VM Instances").
3. Create Custom Dashboard:
   • Click **+ CREATE DASHBOARD**.
   • Click **ADD WIDGET**.
   • Choose a visualization type (e.g., `Line chart`).
   • Select a **Metric** (e.g., `VM Instance > CPU utilization`).
   • Configure aggregation, filters, and display options.
   • Click **ADD**.
   • Click **SAVE DASHBOARD**.

B. Cloud Logging - GUI Usage:

Collects and stores logs from all your GCP resources.

1. Navigate to Logging:

   Google Cloud Console > Navigation menu (☰) > Logging > Logs Explorer

2. Explore Logs:
   • Use the "Query builder" to filter logs by resource type, log name, severity, etc.
   • Apply time range filters.
   • View log entries in the results pane. You can expand individual entries to see detailed JSON.
   • Click "Stream logs" to see new logs in real-time.

C. Cloud Deployment Manager - GUI Usage:

Automates the creation and management of Google Cloud resources using templates.

1. Navigate to Deployment Manager:

   Google Cloud Console > Navigation menu (☰) > Deployment Manager > Deployments

2. Create Deployment:
   • Click **+ CREATE DEPLOYMENT**.
   • Name: (e.g., `my-arm-template-deployment`).
   • **Specify your configuration:** Choose "Upload your configuration" and upload your `.yaml` or `.json` template file (like the `simple-vm-template.json` from the CLI section).
   • Provide parameter values if your template has any.
   • Click **DEPLOY**.
3. Delete Deployment: Select the deployment and click **DELETE** to remove all resources created by it.

11. Developer Tools & DevOps

GCP offers integrated tools to support the entire software development lifecycle.

A. Cloud Source Repositories - GUI Usage:

A fully featured, scalable, and private Git repository service.

1. Navigate to Source Repositories:

   Google Cloud Console > Navigation menu (☰) > Source Repositories

2. Create Repository:
   • Click **+ CREATE REPOSITORY**.
   • Choose "Create new repository" or "Connect external repository".
   • **Name:** (e.g., `my-gcp-repo`).
   • Click **CREATE**.
3. Clone/Push: Instructions for cloning the repo and pushing code will be provided.

B. Cloud Build - GUI Usage:

A continuous integration service.

1. Navigate to Cloud Build:

   Google Cloud Console > Navigation menu (☰) > Cloud Build > Dashboard

2. Create Trigger:
   • Click **TRIGGERS** > **+ CREATE TRIGGER**.
   • **Name:** (e.g., `my-app-ci`).
   • **Event:** (e.g., `Push to a branch`).
   • **Source:** Connect to your Cloud Source Repository, GitHub, Bitbucket, etc.
   • **Build configuration:** Select `Cloud Build configuration file (yaml or json)` and specify its location (e.g., `cloudbuild.yaml`).
   • Click **CREATE**.
3. Run Trigger: You can manually "Run" a trigger or it will activate on code pushes.

C. Cloud Deploy - GUI Usage:

A fully managed continuous delivery service.

1. Navigate to Cloud Deploy:

   Google Cloud Console > Navigation menu (☰) > CI/CD > Cloud Deploy

2. Create Delivery Pipeline: Follow prompts to define targets (e.g., GKE cluster, Cloud Run service) and deployment strategies.

12. Analytics & Machine Learning

GCP is renowned for its strength in data processing, analytics, and AI/ML.

A. BigQuery (Serverless Data Warehouse) - GUI Usage:

A fully managed, serverless, and highly scalable enterprise data warehouse.

1. Navigate to BigQuery:

   Google Cloud Console > Navigation menu (☰) > Analytics > BigQuery

2. Create Dataset:
   • In the Explorer pane, click the three dots next to your project ID > **Create dataset**.
   • Dataset ID: (e.g., `my_analytics_data`).
   • **Data location:** Select.
   • Click **CREATE DATASET**.
3. Create Table:
   • In the Explorer pane, click the three dots next to your new dataset > **Create table**.
   • Choose source (e.g., `Empty table`, `Google Cloud Storage`, `Drive`).
   • Define schema manually or from a file.
   • Click **CREATE TABLE**.
4. Query Data: In the "Query editor" pane, write and run SQL queries.

   # Example SQL query in BigQuery (run this in the editor)
   SELECT
     total_amount,
     passenger_count,
     trip_distance
   FROM
     `bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2017`
   LIMIT 100

   Click **RUN**.

B. Vertex AI (Unified ML Platform) - GUI Usage:

A unified machine learning platform.

1. Navigate to Vertex AI:

   Google Cloud Console > Navigation menu (☰) > Artificial Intelligence > Vertex AI

2. Explore Workbench: Start a Workbench instance (managed Jupyter notebooks) to begin building ML models.
3. AutoML: Explore AutoML capabilities to train custom ML models with minimal code.

13. Cost Management

GCP offers tools and features to help you optimize and control your cloud spending.

1. Navigate to Billing:

   Google Cloud Console > Navigation menu (☰) > Billing > Reports

2. Explore Cost Reports: View your current and forecasted costs, filter by project, service, SKU, etc.
3. Set Budgets: Go to the "Budgets & alerts" tab to create new budgets and set thresholds for notifications.
4. Cost Recommendations: Check the "Cost optimization" section in **Cloud Advisor** (Navigation menu > Tools > Advisor) for personalized recommendations to save money.

14. Best Practices (GCP Well-Architected Framework)

The Google Cloud Well-Architected Framework provides a set of guiding principles and best practices across six pillars to help you build secure, reliable, efficient, and cost-effective workloads on GCP.

• Operational Excellence: Design, deploy, and operate systems effectively. Focus on automation, monitoring, and continuous improvement.
• Security: Protect your data, systems, and assets. Emphasize a strong identity foundation, defense-in-depth, data protection, and proactive security operations.
• Reliability: Build and operate resilient workloads that perform as intended and recover from failures. Focus on redundancy, fault tolerance, and disaster recovery.
• Performance Efficiency: Use computing resources efficiently to meet demands and maintain efficiency as requirements change. Leverage serverless, auto-scaling, and optimized data patterns.
• Cost Optimization: Maximize business value by avoiding unnecessary costs. Focus on rightsizing, discounts, and continuous cost monitoring.
• Sustainability: Minimize the environmental impact of your cloud workloads.