Getting Started: Your First GCP Project
A beginner-friendly guide to launching your first GCP project, covering account setup, project creation, Compute Engine, Cloud Storage, and Cloud Run.
Prerequisites
- A Google account and credit card (free tier available)
- Basic familiarity with command-line terminals
- No prior cloud experience required
Welcome to Google Cloud
Google Cloud Platform (GCP) provides over 200 cloud services spanning compute, storage, databases, networking, machine learning, and more. Whether you are building a simple web application or a planet-scale data pipeline, GCP offers the infrastructure to support your workload. This guide walks you through everything you need to go from zero to your first running application on Google Cloud, with hands-on examples you can follow step by step.
Google Cloud differentiates itself from other cloud providers in several ways: it runs on the same infrastructure that powers Google Search, Gmail, and YouTube; it offers a premium global network with lower latency between regions; and it provides strong data analytics and machine learning services built on technologies like BigQuery and TensorFlow. GCP is also known for its per-second billing, sustained use discounts, and the simplicity of its pricing model.
By the end of this guide, you will have:
- Created a GCP account with the $300 free trial credit
- Set up your first project and configured billing
- Navigated the Cloud Console and installed the gcloud CLI
- Launched your first Compute Engine virtual machine
- Created a Cloud Storage bucket and uploaded files
- Deployed a containerized application on Cloud Run
- Understood basic networking and monitoring concepts
- Learned how to clean up resources to avoid charges
GCP Free Tier and Free Trial
Google Cloud offers two types of free resources. The Free Trial gives new accounts $300 in credit valid for 90 days, usable across all GCP services. The Free Tier provides always-free allowances that persist after the trial ends, including 1 f1-micro Compute Engine instance (Oregon region), 5 GB of Cloud Storage (US regions), 2 million Cloud Functions invocations per month, and more. You will not be charged until you explicitly upgrade your account and exceed the free tier limits.
Setting Up Your GCP Account
Getting started with Google Cloud requires a Google account (Gmail or Google Workspace) and a valid credit card for identity verification. The credit card is not charged during the free trial unless you manually upgrade to a paid account. Here is the step-by-step process:
- Step 1: Navigate to
cloud.google.comand click "Get started for free" or "Start free". - Step 2: Sign in with your Google account. If you do not have one, you can create one during this process.
- Step 3: Accept the terms of service and provide your country, account type (Individual or Business), and payment information.
- Step 4: Google creates your first project automatically (named "My First Project") and activates your $300 free trial credit.
After account creation, install the Google Cloud CLI (gcloud), which is the primary tool for interacting with GCP from your terminal. The gcloud CLI includes gcloud for GCP service management, gsutil for Cloud Storage operations, and bq for BigQuery queries.
# macOS (using Homebrew)
brew install --cask google-cloud-sdk
# Linux (Debian/Ubuntu)
sudo apt-get install apt-transport-https ca-certificates gnupg curl
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee /etc/apt/sources.list.d/google-cloud-sdk.list
sudo apt-get update && sudo apt-get install google-cloud-cli
# Windows (using the installer)
# Download from: https://cloud.google.com/sdk/docs/install#windows
# Initialize the CLI (opens browser for authentication)
gcloud init
# Verify the installation
gcloud --version
# Check your active account and project
gcloud config list
# Set default region and zone
gcloud config set compute/region us-central1
gcloud config set compute/zone us-central1-aUnderstanding the Cloud Console
The Google Cloud Console (console.cloud.google.com) is the web-based management interface for all GCP services. While the gcloud CLI is essential for automation and scripting, the Console provides a visual overview of your resources, real-time monitoring, and an interactive way to explore services. Here are the key areas you will use most:
| Console Area | What It Does | When to Use |
|---|---|---|
| Dashboard | Overview of project resources, billing, and API usage | Quick health check of your project |
| Navigation Menu | Access all GCP services organized by category | Navigating between services |
| Cloud Shell | Browser-based terminal with gcloud pre-installed | Quick commands without local CLI setup |
| IAM & Admin | Manage permissions, service accounts, and organization policies | Setting up access control |
| Billing | View costs, budgets, and billing reports | Monitoring spending and setting budget alerts |
| APIs & Services | Enable/disable GCP APIs for your project | Before using a new service for the first time |
Cloud Shell Is Your Friend
Cloud Shell is a free, browser-based terminal with 5 GB of persistent storage that comes pre-installed with gcloud, kubectl, docker, terraform, and other tools. Click the terminal icon in the top-right corner of the Cloud Console to activate it. Cloud Shell is perfect for running quick commands, tutorials, and experiments without setting up your local environment. It automatically authenticates with your Google account, so you can start running commands immediately.
Projects & Organization
In GCP, a project is the fundamental organizing unit for all resources. Every VM, storage bucket, database, and API is associated with exactly one project. Projects serve three critical purposes: they provide a namespace for resources (resource names must be unique within a project), they are the unit of billing (all resource costs are charged to the project's billing account), and they are the primary boundary for IAM permissions.
Every project has three identifiers:
- Project name: A human-readable label that can contain spaces and special characters. Not unique and can be changed at any time. Example: "My Web App - Production".
- Project ID: A globally unique, immutable identifier. Must be 6-30 characters, lowercase letters, digits, and hyphens. You choose this when creating the project (or accept the auto-generated one). Example:
my-web-app-prod-a1b2c3. - Project number: An auto-generated numeric identifier. Used internally by GCP service accounts and APIs. Example:
123456789012.
# Create a new project
gcloud projects create my-first-app \
--name="My First Application" \
--labels=environment=learning,owner=me
# Set the new project as default
gcloud config set project my-first-app
# Link the project to a billing account
gcloud billing accounts list
gcloud billing projects link my-first-app \
--billing-account=012345-6789AB-CDEF01
# Enable essential APIs for your project
gcloud services enable \
compute.googleapis.com \
storage.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com
# List enabled APIs
gcloud services list --enabled
# View project details
gcloud projects describe my-first-appCreating Your First Compute Engine VM
Compute Engine is GCP's Infrastructure-as-a-Service (IaaS) offering, providing virtual machines that run on Google's infrastructure. VMs are the most flexible compute option. You control the operating system, installed software, networking, and storage. While higher-level services like Cloud Run and GKE abstract away the VM, understanding Compute Engine is foundational to understanding how GCP works.
Let us create a simple web server VM to demonstrate the core concepts:
# Create a VM with a startup script that installs Nginx
gcloud compute instances create my-first-vm \
--zone=us-central1-a \
--machine-type=e2-micro \
--image-family=debian-12 \
--image-project=debian-cloud \
--boot-disk-size=10GB \
--tags=http-server \
--metadata=startup-script='#!/bin/bash
apt-get update
apt-get install -y nginx
cat > /var/www/html/index.html <<HTML
<!DOCTYPE html>
<html>
<head><title>My First GCP VM</title></head>
<body>
<h1>Hello from Google Cloud!</h1>
<p>This page is served from a Compute Engine VM.</p>
<p>Hostname: $(hostname)</p>
<p>Zone: $(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/zone" -H "Metadata-Flavor: Google")</p>
</body>
</html>
HTML'
# Create a firewall rule to allow HTTP traffic
gcloud compute firewall-rules create allow-http \
--direction=INGRESS \
--priority=1000 \
--network=default \
--action=ALLOW \
--rules=tcp:80 \
--source-ranges=0.0.0.0/0 \
--target-tags=http-server \
--description="Allow HTTP traffic to instances with http-server tag"
# Get the external IP address of your VM
gcloud compute instances describe my-first-vm \
--zone=us-central1-a \
--format='get(networkInterfaces[0].accessConfigs[0].natIP)'
# SSH into your VM
gcloud compute ssh my-first-vm --zone=us-central1-a
# List all your VMs
gcloud compute instances list
# Stop the VM (to save costs when not in use)
gcloud compute instances stop my-first-vm --zone=us-central1-a
# Start the VM again
gcloud compute instances start my-first-vm --zone=us-central1-aRemember to Stop or Delete Unused VMs
Running VMs incur charges even when idle. An e2-micro instance is included in the free tier (one per billing account, in select US regions), but larger machine types will consume your free trial credit. Always stop VMs when you are not using them, or delete them entirely when you are done experimenting. Use gcloud compute instances delete my-first-vm --zone=us-central1-a to delete a VM and its associated disks.
Machine Type Quick Reference
| Machine Type | vCPUs | Memory | Use Case | Approx. Monthly Cost |
|---|---|---|---|---|
e2-micro | 0.25 (shared) | 1 GB | Free tier, tiny workloads | Free (1 per account, US regions) |
e2-small | 0.5 (shared) | 2 GB | Light web servers, dev environments | ~$13 |
e2-medium | 1 (shared) | 4 GB | Small applications, CI workers | ~$25 |
e2-standard-2 | 2 | 8 GB | General-purpose workloads | ~$49 |
e2-standard-4 | 4 | 16 GB | Medium applications, databases | ~$97 |
Setting Up Cloud Storage
Cloud Storage is GCP's object storage service, similar to Amazon S3 or Azure Blob Storage. It stores files (called objects) in containers (called buckets). Cloud Storage is durable (99.999999999% annual durability), highly available, and can serve content directly to the internet. It is used for everything from hosting static websites to storing machine learning training data and database backups.
Every bucket has a globally unique name (across all GCP customers), a storage class, and a geographic location. The storage class determines the pricing and availability characteristics:
| Storage Class | Min Storage Duration | Use Case | Storage Cost (per GB/month) |
|---|---|---|---|
| Standard | None | Frequently accessed data | $0.020 (US multi-region) |
| Nearline | 30 days | Accessed less than once a month | $0.010 |
| Coldline | 90 days | Accessed less than once a quarter | $0.004 |
| Archive | 365 days | Long-term archival, compliance | $0.0012 |
# Create a bucket (name must be globally unique)
gcloud storage buckets create gs://my-first-app-storage-12345 \
--location=us-central1 \
--default-storage-class=STANDARD \
--uniform-bucket-level-access
# Upload a file
echo "Hello, Cloud Storage!" > hello.txt
gcloud storage cp hello.txt gs://my-first-app-storage-12345/
# Upload a directory
gcloud storage cp -r ./my-website gs://my-first-app-storage-12345/website/
# List bucket contents
gcloud storage ls gs://my-first-app-storage-12345/
# Download a file
gcloud storage cp gs://my-first-app-storage-12345/hello.txt ./downloaded.txt
# Make a file publicly readable (for static website hosting)
gcloud storage objects update gs://my-first-app-storage-12345/website/index.html \
--add-acl-grant=entity=allUsers,role=READER
# Configure the bucket as a static website
gcloud storage buckets update gs://my-first-app-storage-12345 \
--web-main-page-suffix=index.html \
--web-error-page=404.html
# Set lifecycle rules to automatically manage storage costs
gcloud storage buckets update gs://my-first-app-storage-12345 \
--lifecycle-file=lifecycle.json
# Check bucket size and object count
gcloud storage du -s gs://my-first-app-storage-12345/{
"rule": [
{
"action": {
"type": "SetStorageClass",
"storageClass": "NEARLINE"
},
"condition": {
"age": 30,
"matchesStorageClass": ["STANDARD"]
}
},
{
"action": {
"type": "SetStorageClass",
"storageClass": "COLDLINE"
},
"condition": {
"age": 90,
"matchesStorageClass": ["NEARLINE"]
}
},
{
"action": {
"type": "Delete"
},
"condition": {
"age": 365
}
}
]
}Deploying with Cloud Run
Cloud Run is the easiest way to deploy a containerized application on GCP. It is a fully managed serverless platform that automatically scales your containers from zero to thousands of instances based on incoming requests. You pay only for the compute resources your application uses while processing requests, making it extremely cost-effective for applications with variable traffic.
Cloud Run accepts any Docker container that listens on a port (default 8080) and responds to HTTP requests. You do not need to write a Dockerfile if your application uses a supported language. Cloud Run can build your source code using Google Cloud Buildpacks.
# Option 1: Deploy from source code (no Dockerfile needed)
# Cloud Run will detect the language and build the container automatically
mkdir my-cloud-run-app && cd my-cloud-run-app
# Create a simple Node.js application
cat > package.json << 'EOF'
{
"name": "my-cloud-run-app",
"version": "1.0.0",
"scripts": {
"start": "node server.js"
},
"dependencies": {
"express": "^4.18.0"
}
}
EOF
cat > server.js << 'EOF'
const express = require('express');
const app = express();
const port = process.env.PORT || 8080;
app.get('/', (req, res) => {
const name = process.env.NAME || 'World';
res.json({
message: `Hello, ${name}! Welcome to Cloud Run.`,
timestamp: new Date().toISOString(),
revision: process.env.K_REVISION || 'local',
service: process.env.K_SERVICE || 'local'
});
});
app.get('/health', (req, res) => {
res.status(200).json({ status: 'healthy' });
});
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});
EOF
# Deploy from source (Cloud Build + Cloud Run)
gcloud run deploy my-first-service \
--source=. \
--region=us-central1 \
--allow-unauthenticated \
--set-env-vars=NAME=GCP \
--min-instances=0 \
--max-instances=3 \
--memory=256Mi \
--cpu=1
# Option 2: Deploy a pre-built container image
gcloud run deploy my-first-service \
--image=us-docker.pkg.dev/cloudrun/container/hello \
--region=us-central1 \
--allow-unauthenticated
# Get the service URL
gcloud run services describe my-first-service \
--region=us-central1 \
--format='value(status.url)'
# View service logs
gcloud run services logs read my-first-service \
--region=us-central1 \
--limit=20
# Update environment variables
gcloud run services update my-first-service \
--region=us-central1 \
--set-env-vars=NAME=Developer
# List all Cloud Run services
gcloud run services list --region=us-central1Cloud Run vs Compute Engine
Use Cloud Run when you have a containerized web application or API that responds to HTTP requests. It scales to zero (no charges when idle), handles auto-scaling automatically, and requires no infrastructure management. Use Compute Engine when you need persistent background processes, specific operating system configurations, GPU access, or applications that cannot be containerized. For most new web applications and APIs, Cloud Run is the recommended starting point.
VPC & Networking Basics
Every GCP project comes with a default VPC network that spans all regions, with pre-configured subnets and firewall rules that allow internal communication and SSH access. While the default network is convenient for learning, production workloads should use custom VPC networks with explicit subnet definitions and tighter firewall rules.
Key networking concepts for beginners:
- VPC Network: A virtual private cloud network that provides connectivity for your GCP resources. VPCs are global (they span all regions), but subnets are regional.
- Subnets: Regional IP address ranges within a VPC. Every VM instance must be placed in a subnet, which determines its internal IP address range and region.
- Firewall rules: Control inbound (ingress) and outbound (egress) traffic to your VMs. Rules are applied at the network level and can target instances by network tags or service accounts.
- External IP: A public IP address that allows your VM to be reached from the internet. Ephemeral IPs change when the VM restarts; static IPs persist.
- Cloud NAT: Allows VMs without external IPs to access the internet for outbound connections (e.g., downloading packages) without being directly reachable from outside.
# List VPC networks in your project
gcloud compute networks list
# List subnets in the default network
gcloud compute networks subnets list --network=default
# List firewall rules
gcloud compute firewall-rules list
# Create a custom VPC network (recommended for production)
gcloud compute networks create my-custom-vpc \
--subnet-mode=custom \
--bgp-routing-mode=regional
# Create subnets in specific regions
gcloud compute networks subnets create web-subnet \
--network=my-custom-vpc \
--region=us-central1 \
--range=10.0.1.0/24
gcloud compute networks subnets create db-subnet \
--network=my-custom-vpc \
--region=us-central1 \
--range=10.0.2.0/24
# Create firewall rules for the custom network
gcloud compute firewall-rules create allow-internal \
--network=my-custom-vpc \
--allow=tcp,udp,icmp \
--source-ranges=10.0.0.0/16
gcloud compute firewall-rules create allow-ssh \
--network=my-custom-vpc \
--allow=tcp:22 \
--source-ranges=0.0.0.0/0 \
--target-tags=allow-ssh
# Reserve a static external IP address
gcloud compute addresses create my-static-ip \
--region=us-central1Monitoring Your Resources
Even as a beginner, setting up basic monitoring ensures you know when something goes wrong and helps you understand your resource utilization. GCP's Cloud Monitoring (part of the Google Cloud Operations suite) provides built-in metrics for every GCP service without any additional configuration. For Compute Engine VMs, you get CPU utilization, network traffic, and disk I/O metrics out of the box.
Essential monitoring tasks for beginners:
- Set up a budget alert: The most important monitoring task for new users. Create a budget in the Billing section to receive email alerts when spending reaches 50%, 90%, and 100% of your threshold.
- View the dashboard: The Cloud Console Dashboard shows an overview of all active resources, recent API activity, and billing summaries.
- Check logs: Use the Logs Explorer to view application logs, system logs, and audit logs across all your services.
- Create an uptime check: For web-facing services, create an uptime check that pings your URL every minute and alerts you when it becomes unreachable.
# Create a budget alert (prevents surprise charges)
gcloud billing budgets create \
--billing-account=012345-6789AB-CDEF01 \
--display-name="Learning Budget" \
--budget-amount=25.00USD \
--threshold-rule=percent=0.5 \
--threshold-rule=percent=0.9 \
--threshold-rule=percent=1.0
# View current billing information
gcloud billing accounts describe 012345-6789AB-CDEF01
# View Compute Engine VM metrics
gcloud monitoring metrics list \
--filter='metric.type = starts_with("compute.googleapis.com/instance")'
# View Cloud Run metrics
gcloud monitoring metrics list \
--filter='metric.type = starts_with("run.googleapis.com")'
# View recent logs for your VM
gcloud logging read 'resource.type="gce_instance"' \
--limit=20 \
--format='table(timestamp, severity, textPayload)'
# View Cloud Run service logs
gcloud logging read 'resource.type="cloud_run_revision"
AND resource.labels.service_name="my-first-service"' \
--limit=20Set Up Billing Alerts Immediately
The single most important thing you can do as a new GCP user is set up billing alerts. Even with the free trial, it is possible to accidentally create expensive resources (like a high-memory VM or a large database) that consume your $300 credit quickly. Go to Billing → Budgets & Alerts in the Cloud Console and create a budget for $25 with email notifications at 50%, 90%, and 100% thresholds. This takes two minutes and can save you from unexpected charges.
Cleaning Up & Avoiding Charges
When you are done experimenting, cleaning up your resources is essential to avoid ongoing charges. Even stopped VMs incur costs for their persistent disks and reserved IP addresses. The most thorough way to clean up is to delete the entire project, which removes all resources and stops all billing. However, if you want to keep the project, delete individual resources.
# Option 1: Delete individual resources
# Delete Compute Engine VM and its disk
gcloud compute instances delete my-first-vm --zone=us-central1-a --quiet
# Delete the firewall rule
gcloud compute firewall-rules delete allow-http --quiet
# Delete Cloud Run service
gcloud run services delete my-first-service \
--region=us-central1 --quiet
# Delete Cloud Storage bucket and all its contents
gcloud storage rm -r gs://my-first-app-storage-12345
# Delete custom VPC network (must delete subnets and firewall rules first)
gcloud compute firewall-rules delete allow-internal --quiet
gcloud compute firewall-rules delete allow-ssh --quiet
gcloud compute networks subnets delete web-subnet \
--region=us-central1 --quiet
gcloud compute networks subnets delete db-subnet \
--region=us-central1 --quiet
gcloud compute networks delete my-custom-vpc --quiet
# Release static IP addresses
gcloud compute addresses delete my-static-ip \
--region=us-central1 --quiet
# Option 2: Delete the entire project (removes EVERYTHING)
gcloud projects delete my-first-app
# Verify no resources remain
gcloud compute instances list
gcloud run services list
gcloud storage buckets listCost-Saving Tips for Learners
- Use the free tier: The f1-micro VM in Oregon (us-west1) and 5 GB of Standard Cloud Storage in US regions are always free. Use these for persistent learning environments.
- Stop VMs when not in use: A stopped VM does not incur compute charges, only disk storage charges. Stop your VMs at the end of each session.
- Use Cloud Run for experiments: Cloud Run scales to zero and charges only for actual request processing time. It is essentially free for low-traffic learning projects.
- Delete resources after tutorials: After completing a tutorial or experiment, immediately delete the resources. Do not leave things running "just in case."
- Use preemptible/spot VMs: For learning workloads that do not need high availability, spot VMs cost 60-91% less than regular VMs. They can be terminated by Google at any time, but for experimentation this is rarely an issue.
- Check billing daily: During your first week, check the Billing Dashboard daily to understand which resources are generating costs.
What to Learn Next
Now that you have the fundamentals, here are recommended next steps based on your goals: For web applications, explore Cloud SQL for managed databases and Cloud CDN for content delivery. For data engineering, look into BigQuery for analytics and Dataflow for stream/batch processing. For DevOps, learn about Cloud Build for CI/CD and Terraform for infrastructure as code. For microservices, explore GKE for Kubernetes or Cloud Run for simpler container orchestration.
Key Takeaways
- 1GCP free trial provides $300 in credits for 90 days plus always-free tier services.
- 2Projects are the fundamental unit of organization, and every resource belongs to a project.
- 3Compute Engine provides VMs with per-second billing and automatic sustained-use discounts.
- 4Cloud Storage offers globally available object storage with multiple storage classes.
- 5Cloud Run deploys containers without managing servers and scales to zero and back.
- 6Always delete projects or resources when done experimenting to avoid charges.
Frequently Asked Questions
Is the GCP free trial really free?
What is a GCP project?
How do I avoid unexpected GCP charges?
Which GCP region should I use?
What is Cloud Shell?
Written by CloudToolStack Team
Cloud engineers and architects with hands-on experience across AWS, Azure, and GCP. We write guides based on real-world production patterns, not just documentation rewrites.
Disclaimer: This guide is for educational purposes. Cloud services change frequently; always refer to official documentation for the latest information. AWS, Azure, and GCP are trademarks of their respective owners.