GCP Fundamentals · Lesson 1 of 10

Getting Started with Google Cloud

What the cloud actually is, how Google Cloud is organised, and your first look around the Google Cloud Console — no previous cloud experience needed, and nothing to set up or pay for in this lesson.

What Are We Learning?

Imagine you've built an application. Maybe it's a small study app, a website, or an API. It works perfectly on your own computer.

But now you want people around the world to use it. Your computer can't realistically stay switched on forever, serving thousands of users, day and night. You need computers somewhere else that can:

  • run your application
  • store your files
  • store your database
  • handle your users
  • process their requests
  • stay available 24/7

That is what a cloud platform gives you. In this course, that platform is Google Cloud Platform — GCP for short.

We won't start with a long list of product names. Instead, here's the first picture to keep in your head: 

            Google Cloud
                 │
          ┌──────┴──────┐
          │   Project   │
          └──────┬──────┘
                 │
    ┌────────────┼────────────┐
    │            │            │
 Compute      Storage     Database
    │            │            │
 Run apps   Store files  Store data
Your resources live inside a project in Google Cloud: somewhere to run apps, store files and store data.

By the end of this lesson, every part of that picture will make sense.

First: What Is "the Cloud"?

The simplest honest definition is:

Key idea

The cloud is somebody else's computers that you can use over the internet.

Google owns enormous buildings called data centers, filled with thousands of powerful computers called servers. When you use Google Cloud, you're borrowing a small part of those computers — only what you need, only for as long as you need it.

So instead of buying and running your own hardware, you can simply ask for what you need:

"I need a computer."

"I need 100 GB of storage."

"I need somewhere to store
 my application's data."
Three everyday cloud requests.

Google Cloud has a service for each of these. You ask, and within moments the computer, storage or database is ready to use.

Think of GCP as a Giant Toolbox

Google Cloud has a lot of services — far too many to learn at once. The good news is that you don't need to. Think of GCP as a giant toolbox, organised into a few kinds of tools: 

GCP
 │
 ├── 🖥️ Compute
 │      Run applications
 │
 ├── 📦 Storage
 │      Store files
 │
 ├── 🗄️ Databases
 │      Store structured data
 │
 ├── 🌐 Networking
 │      Connect everything
 │
 └── 🔐 IAM
        Control who can do what
Five kinds of tools: compute, storage, databases, networking and IAM (Identity and Access Management).

Each kind of tool solves a kind of problem. When you have a problem, you pick the tool for it: 

Need a computer?
        ↓
Compute Engine

Need file storage?
        ↓
Cloud Storage

Need to run an app without
managing servers?
        ↓
Cloud Run

Need a relational database?
        ↓
Cloud SQL
Start from the problem; the service follows.
Key idea

Services come after concepts. First understand what you need — a computer, storage, a database — and then learn the Google Cloud service that provides it. That's the order this whole course follows.

What Is a Google Cloud Project?

Everything you create in Google Cloud lives inside a project. Imagine you're building an app called StudyBuddy. Its server, its files and its database would all belong to one project: 

    Google Cloud
          │
          ▼
┌────────────────────┐
│ StudyBuddy Project │
└────────────────────┘
          │
   ┌──────┼───────┐
   │      │       │
   ▼      ▼       ▼
  VM   Storage  Database
The StudyBuddy project holds everything that belongs to the StudyBuddy app.

A project is a container — an organisational boundary around a set of cloud resources. It keeps everything for one app or purpose together, and separate from everything else. A project organises your:

  • Resources — the servers, storage, databases and other things you create.
  • Permissions — who is allowed to see or change them.
  • APIs — which Google Cloud services are switched on for this project. A service's API needs to be enabled in a project before you can use it there.
  • Billing — the project is linked to a billing account, which pays for what the project uses.
  • Monitoring — the logs and metrics that tell you what's happening inside it.

Every project has a Project ID: a unique name that identifies it across all of Google Cloud, such as studybuddy-app-12345. You'll see it in the Console and use it with command-line tools. The display name of a project can be changed later, but the Project ID stays the same for the life of the project.

Regions and Zones

Google's data centers are spread across the world. When you create something in Google Cloud, you choose roughly where it runs, using regions and zones: 

Region
│
├── Zone A
├── Zone B
└── Zone C
Each region contains several zones.
  • A region is a geographic area — for example, us-central1 in Iowa or europe-west2 in London.
  • A zone is a separate deployment area inside a region, such as us-central1-a.

Why have several zones in one region? Because things occasionally go wrong — a power problem, a network fault, a hardware failure. Zones are kept separate from each other, so if one zone has a problem, the others can keep running. You'll mostly just pick a region close to your users for now; designing across zones and regions comes much later.

Meet the Google Cloud Console

The Google Cloud Console, at console.cloud.google.com, is the website where you manage everything in Google Cloud. It's where most of the hands-on work in this course happens.

At a high level, it looks like this:

Google Cloud Console

Project selector
      │
      ├── Compute Engine
      ├── Cloud Storage
      ├── Cloud Run
      ├── IAM
      └── Billing
Choose a project first; then the services you open work inside that project.

The project selector decides which project you're working in. Everything you open after that — Compute Engine, Cloud Storage, Cloud Run, IAM, Billing — shows the resources of the selected project.

In the coming lessons, you'll use the Console a lot. But the goal is never just: 

Click this → click that → done.

Each time, we'll stop and look at what Google Cloud actually did underneath — what was created, where it lives, and how it connects to everything else. That understanding is what lets you solve problems the Console buttons don't show you.

Note

Google updates the Console's layout from time to time, so menus may not sit exactly where a screenshot or video suggests. The concepts in this course don't change — and you can always use the Console's search to find a service by name.

And Eventually: Cloud Shell

Clicking through the Console is a great way to learn. But there's a second way to work with Google Cloud: typing commands. Cloud Shell is a terminal that opens in your browser from the Console, with Google Cloud's command-line tool, gcloud, already installed and signed in as you.

For example, this command lists the projects you have access to:

gcloud projects list

The important thing to understand is that the Console and Cloud Shell aren't two different clouds:

Console
   │
   │ same cloud resources
   │
Cloud Shell / gcloud
Two ways to work with the same cloud environment.

A project created in the Console shows up in gcloud, and something created with gcloud appears in the Console. We'll introduce commands gradually, one at a time, alongside the Console — you don't need to learn gcloud yet.

What Did We Actually Learn?

Cloud computing means your app runs on Google's computers instead of yours:

Your App
   ↓
Google Cloud
   ↓
Servers / Storage / Databases

A project holds your cloud resources together:

Project
 ├── Compute
 ├── Storage
 └── Database

Regions are geographic areas, and each contains several zones:

Region
 ├── Zone A
 ├── Zone B
 └── Zone C

And you work with all of it through the Console — and, gradually, through Cloud Shell and gcloud.

Key idea

You don't need to learn all of GCP. You learn the services you need to solve a particular problem — and each lesson in this course is built around one of those problems.

Tiny Challenge

Your turn

Open the Google Cloud Console and look at the project selector. For the project that's selected, find its:

  • Project Name
  • Project ID
  • Project Number

Then find each of these services in the Console:

  • Compute Engine
  • Cloud Storage
  • Cloud Run
  • IAM
  • Billing

Important: don't create anything yet. This challenge is only about finding your way around:

  • No VM.
  • No bucket.
  • No database.
  • No billing changes.
  • No deployments.

Just look around and get comfortable. Creating things starts in Lesson 2.

Coming Next

In Lesson 2 — Your First Server in the Cloud, you'll create a virtual machine in Google Cloud and use it to put a web page on the internet: 

Your Computer
      │
      │ Internet
      ▼
┌─────────────────────┐
│   Google Cloud VM   │
│                     │
│   Linux             │
│   Web Server        │
│   Your Web Page     │
└─────────────────────┘
      │
      ▼
https://...
Your first server: a Google Cloud VM serving a web page.

Along the way you'll meet Compute Engine, VMs, CPU, RAM, disks, IP addresses, SSH and firewalls — not as a list of terms to memorise, but as parts of one story: getting your web page online.

Every lesson in this course follows the same rhythm:

concept
  → visual explanation
  → Console hands-on
  → understand what happened
  → experiment
  → tiny challenge
  → real project