Google Cloud CLI (gcloud) – Essential Commands for Beginners

What is gcloud?

gcloud is the Google Cloud Command Line Interface (CLI). It lets you manage your Google Cloud resources directly from the Terminal instead of using the web console.

You can use gcloud to:

• Create and manage projects
• Enable APIs
• Deploy applications
• Manage virtual machines
• Work with Cloud Run
• Configure billing
• Create service accounts
• Manage AI services such as Gemini

---

Numbered gcloud Commands

1. Check whether gcloud is installed

gcloud --version

Displays the installed Google Cloud SDK version.

---

2. Update gcloud

gcloud components update

Updates the Google Cloud SDK to the latest version.

---

3. Sign in

gcloud auth login

Opens your browser so you can sign in with your Google account.

---

4. List authenticated accounts

gcloud auth list

Shows every Google account currently authenticated.

---

5. Change active account

gcloud config set account your-email@gmail.com

Sets the active Google account.

---

6. List projects

gcloud projects list

Displays every project you have access to.

---

7. Set the active project

gcloud config set project PROJECT_ID

Sets the active Google Cloud project.

Example:

gcloud config set project kiaapp-agent

All future commands use this project.

---

8. Show current project

gcloud config get-value project

Displays the currently selected project.

---

9. Describe a project

gcloud projects describe PROJECT_ID

Shows detailed information about a project.

---

10. Check billing status

gcloud billing projects describe PROJECT_ID

Shows whether billing is enabled for the project.

---

11. List billing accounts

gcloud billing accounts list

Displays available billing accounts.

---

12. Enable an API

gcloud services enable API_NAME

Enables a Google Cloud service.

Example:

gcloud services enable aiplatform.googleapis.com

Enables the Vertex AI API.

---

13. List enabled APIs

gcloud services list

Shows APIs enabled in the current project.

---

14. List all available APIs

gcloud services list --available

Lists every Google Cloud API available for use.

---

15. List configurations

gcloud config configurations list

Shows all saved gcloud configuration profiles.

---

16. Show current configuration

gcloud config list

Displays the active configuration settings.

---

17. Create a configuration

gcloud config configurations create my-config

Creates a new configuration profile.

---

18. Activate a configuration

gcloud config configurations activate my-config

Switches to another configuration.

---

19. Deploy an application

gcloud run deploy

Deploys your application to Cloud Run.

---

20. List Cloud Run services

gcloud run services list

Displays deployed Cloud Run services.

---

21. Delete a service

gcloud run services delete SERVICE_NAME

Deletes a Cloud Run service.

---

22. List virtual machines

gcloud compute instances list

Displays Compute Engine virtual machine instances.

---

23. Create a virtual machine

gcloud compute instances create VM_NAME

Creates a new Compute Engine virtual machine.

---

24. List Cloud Storage buckets

gcloud storage buckets list

Displays Cloud Storage buckets.

---

25. Create a Cloud Storage bucket

gcloud storage buckets create gs://BUCKET_NAME

Creates a new Cloud Storage bucket.

---

26. List service accounts

gcloud iam service-accounts list

Displays all service accounts in the project.

---

27. Create a service account

gcloud iam service-accounts create NAME

Creates a new service account.

---

28. Enable the Vertex AI API

gcloud services enable aiplatform.googleapis.com

Enables Vertex AI so you can use AI models such as Gemini.

---

29. Check the active project before using Gemini

gcloud config get-value project

Confirms that Gemini requests will use the correct Google Cloud project.

---

30. Show general help

gcloud help

Displays general help for the gcloud command-line tool.

---

31. Show Compute Engine help

gcloud compute --help

Displays all Compute Engine commands and their usage.

---

32. Show Cloud Run help

gcloud run --help

Displays all Cloud Run commands and their usage.

---

33. Print current SDK information

gcloud info

Displays Google Cloud SDK installation details, environment information, and the active configuration.

Before comparing every AI model, one important point needs to be clear: ChatGPT is not the model. ChatGPT is the app. GPT is the model behind it. Think of ChatGPT as a door you walk through to access GPT. Copilot, Gemini, and Claude work in a similar way. Each has a different interface, logo, and product experience, but behind them sits a powerful AI model doing the real work.

Most AI models are trained on huge amounts of text, code, books, articles, and websites. They do not “memorize” information in the way humans do. Instead, they learn patterns. At the most basic level, many of these models predict the next word, or more accurately, the next token. That may sound simple, but when done extremely well, it can produce essays, explain science, write code, summarize documents, and answer complex questions. It is like autocomplete, but trained on a massive amount of information and improved to understand context far better.

Two important ideas help explain why some models feel smarter than others: parameters and context window. Parameters are like the internal settings the model uses to recognize patterns. More parameters usually mean the model can understand more complex relationships. The context window is how much information the model can keep in mind during a conversation. A larger context window means you can give it longer documents, bigger code files, or extended conversations without it losing track.

Some newer models also include stronger reasoning abilities. These models do not just answer immediately; they take more time to work through the problem. That makes them slower, but often much better for math, logic, coding, planning, and multi-step tasks.

GPT, developed by OpenAI, is one of the most well-known model families because it is strong across many tasks. It can help with writing, analysis, coding, image-related work, voice interaction, and general problem solving. Its biggest advantage is not only the model itself, but the ecosystem around it. Many apps, plugins, businesses, and third-party tools are built around OpenAI’s GPT models, which makes them widely useful in everyday work.

Gemini, developed by Google DeepMind, is especially powerful because of its integration with Google’s ecosystem. If someone already uses Gmail, Google Docs, Sheets, Android, Search, or Maps, Gemini fits naturally into that workflow. Its strength is not only answering questions, but also helping inside the tools people already use every day.

Claude, developed by Anthropic, is often preferred for coding, long-document analysis, and deep reasoning. Many developers recommend Claude because it can review code, explain complex systems, and produce well-structured summaries. It is also known for providing more balanced and direct feedback rather than simply agreeing with every suggestion.

Grok, developed by xAI, is best known for its integration with X (formerly Twitter) and its ability to analyze real-time conversations and trending topics. This makes it particularly useful for following breaking news, monitoring public sentiment, and understanding online discussions as they happen.

DeepSeek, developed by DeepSeek AI, represents another important direction in AI development. As an open-source model, it allows users to download and run AI locally instead of relying on cloud services. Other open-source models such as Llama from Meta, Qwen from Alibaba, and Mistral from Mistral AI also give users greater control, improved privacy, and the ability to run powerful AI models on their own hardware.

Beyond conversational models, there are also specialized AI systems. Midjourney is widely regarded for producing highly artistic images. DALL·E, developed by OpenAI, is easy to use and performs particularly well when generating images containing readable text. Flux and Stable Diffusion offer greater customization and are popular among users who want to generate images locally.

For AI-generated video, Sora from OpenAI, Runway, and Kling are among the leading platforms, while Suno and Udio have become popular for creating complete songs with vocals and instruments from simple text prompts.

The next major evolution is AI agents. Instead of simply answering questions, AI agents can browse websites, execute code, manage files, fill out forms, and complete complex multi-step tasks with limited human supervision. Systems such as OpenAI Operator, Google Project Mariner, and Anthropic Computer Use demonstrate how AI is evolving from a conversational assistant into an autonomous digital worker.

The best strategy today is not to rely on a single AI model. Use GPT for general-purpose work, Gemini if you live inside Google’s ecosystem, Claude for programming and detailed analysis, Perplexity for research with source citations, and Llama or DeepSeek if privacy and local execution are priorities. AI is becoming less like one universal application and more like a complete toolbox, where choosing the right model for the right task produces the best results.

If you want to build your first AI agent on Windows safely without affecting your main Python installation, this is the cleanest way.

---

1. Create your project folder(Command Prompt / PowerShell)

This creates a new workspace for your AI project.

mkdir ai-agent

---

2. Move into your project folder

Enter your project directory.

cd ai-agent

Think of this as entering your AI workshop.

---

3. Create a virtual environment(Important for safety)

This creates a private Python environment for your project.

It protects your main Python installation from package conflicts.

python -m venv venv

This creates:

ai-agent\
└── venv\

Why this matters:

Without it, installing packages can break:

• global Python packages
• other projects
• dependency versions

With it, your project stays isolated.

---

4. Activate the virtual environment

On Windows:

venv\Scripts\activate

After activation you should see:

(venv) C:\Users\YourName\ai-agent>

That means your isolated environment is active.

---

5. Install Google ADK

Install the toolkit:

pip install google-adk

This installs only inside your venv.

---

6. Create your Python file

Create your agent file:

type nul > agent.py

Or create it manually inside your editor.

---

7. Open your project in Cursor / VS Code

Open the whole:

ai-agent

folder.

Then open:

agent.py

Paste:

from google.adk.agents import Agent

root_agent = Agent(
    name="hello_agent",
    model="gemini-2.0-flash",
    instruction="You are a helpful AI assistant."
)

Save it.

---

8. Add your Google API key

Connect your agent to Google Gemini:

set GOOGLE_API_KEY=your_key_here

Replace with your real API key.

Important:

This only works for the current terminal session.

---

9. Start your AI agent

Run:

adk web

This launches the local web interface.

---

10. Open in browser

Go to:

http://localhost:8000

Your AI agent is now live.

You can chat with it directly.

---

What you built

You now have:

✅ Your first AI agent
✅ Running locally on Windows
✅ Connected to Google Gemini
✅ Protected inside an isolated Python environment
✅ Ready to expand with APIs, tools, memory, and workflows

Think of it like:

• Project folder = workshop
• venv = protected lab
• agent.py = brain
• API key = power source
• adk web = engine
• localhost = control center

Important safety rules

🚫 Never share your API key
🚫 Never install packages globally unless needed
🚫 Never skip the virtual environment
🚫 Avoid pip install outside venv

Right now, somewhere in the world, an AI agent is booking flights, writing code, and answering customer questions—and it has absolutely no idea what it was doing five minutes ago. It’s like handing the keys to your company to a genius goldfish. Smart? Absolutely. Reliable? Not so much.

Today, we’re going to fix that.

We’re talking about something that sounds boring at first, but trust me, it’s one of the most important ideas in AI right now: operating systems. Not the kind on your laptop, but operating systems for AI agents. And by the end of this video, you’ll understand why this might be one of the most important pieces of AI infrastructure that almost nobody is talking about.

Let’s start simple.

Imagine you’re a kid in a kindergarten with no teacher. Nobody tells you where to sit, nobody organizes snack time, nobody makes sure nap time happens, and nobody stops the kids from turning finger paint into complete chaos. Sounds messy, right? Of course it does.

Now imagine the teacher walks in. Maybe she’s wearing a bright red jacket and carrying a whistle. Suddenly everything changes. There’s structure. Story time is at nine, snack time is at ten, nap time is after lunch, and if someone decides it’s a great idea to throw blocks across the room, there’s someone there to handle it.

That teacher? That’s an operating system.

On your computer, the operating system is the invisible manager making everything work together. When you open Spotify, it figures out how to send music to your speakers. When you open Google Chrome and Microsoft Word at the same time, it makes sure they share memory and processing power without fighting. Plug in a USB drive, and the OS recognizes it and makes it usable. You barely notice it, but without it, your computer is basically just an expensive paperweight.

Whether it’s Windows, macOS, or Linux, all operating systems do the same thing: they manage memory, schedule tasks, control access, and stop everything from crashing into everything else.

Now here’s where it gets interesting.

We’ve entered the age of AI agents. These aren’t just chatbots anymore. They don’t just answer questions—they do things. They can book flights, track expenses, write and run code, send emails, call APIs, and even talk to other agents. They’re basically digital employees.

But there’s a problem.

Right now, most AI agents are like toddlers running around unsupervised. They forget what they were doing, they don’t know what tools they’re allowed to use, they can’t explain why they made a decision, and they definitely don’t understand that deleting your production database is probably a terrible idea.

Every new conversation feels like a memory wipe.

“Hi, I’m your AI assistant. What’s your name?”

Buddy… we’ve talked fourteen times this week.

And when multiple agents try to work together, it’s like putting five toddlers in charge of a restaurant. Someone is ending up in the soup.

That’s why we need supervision.

What we really need is an operating system for AI agents.

An Agent OS does for AI agents what an operating system does for apps. It manages resources, schedules work, stores memory, controls permissions, and keeps everything from going completely off the rails.

Think of it like a three-layer cake.

At the top, you have the AI agents themselves—the workers. Your travel agent, your coding agent, your customer support agent. Each one has a specific job. In the middle, you have the Agent OS kernel. This is the teacher’s desk, where all the coordination happens. And at the bottom, you have the infrastructure: the computers, the AI models, the databases, the APIs, and the tools that make everything possible.

Now the middle layer is where the magic happens.

First, there’s the scheduler. Think of it as the teacher’s daily plan. If ten agents all want to use the AI model at once, someone has to decide who goes first. Should the live customer support chat get priority over a background report? The scheduler makes that call.

Then there’s memory management, which solves the goldfish problem. It gives agents short-term memory for the task they’re working on, long-term memory for past work, and even experience-based memory—like remembering that the last time they tried something, it failed. So if your HR agent helped you with parental leave last month, it won’t start from zero when you come back.

Next is the tool manager. Agents need tools—email, databases, APIs, code execution. The tool manager organizes all of that. It knows what tools exist, who can use them, and runs them inside a sandbox. Why? Because if an agent writes code, you don’t want it accidentally wiping your live database. The sandbox is like a safe playroom where the agent can experiment without breaking the house.

Then comes identity management. This answers a simple question: who are you, and what are you allowed to do? Just like employees have ID badges, agents need credentials too. Temporary tokens, limited permissions, and clear ownership. If your travel agent books a flight using your card, there should be a clear record showing it acted on your behalf.

After that comes observability—basically the security camera system. Every action, every tool call, every decision gets logged. If something goes wrong, you can rewind the tape and see exactly why. If an agent approves a refund it shouldn’t have, observability helps you trace the mistake.

And finally, there are guardrails and governance. These are the rules. The boundaries. The “maybe don’t do that” system. Input guardrails check what comes in. Is someone trying to trick the agent? Output guardrails check what goes out. Is the agent about to say something harmful or incorrect? And governance decides when humans need to step in—the human-in-the-loop system. For example, refunds under fifty dollars might be automatic. Over fifty? That needs human approval.

So why does any of this matter?

Because AI agents aren’t some future concept anymore. They’re here now. Companies are already using them for customer service, coding, operations, and financial decisions. And many are doing it without the infrastructure to manage them properly.

That’s like running a busy city without traffic lights.

It works… until it doesn’t.

The teams building Agent OS today will scale faster, safer, and more reliably. Everyone else will be stuck managing expensive, fragile experiments with goldfish memories.

So here’s the big takeaway: a traditional operating system keeps apps organized and working together. An Agent OS does the same for AI agents. It manages scheduling, memory, tools, identity, observability, and guardrails.

Without it, agents are smart—but chaotic.

With it, they become infrastructure you can actually trust.

The age of AI agents is already here.

The real question is: who’s going to be the teacher?

AI agents are designed to handle tasks that are far more complex than what a standalone large language model can solve with its built-in knowledge. A single model can answer questions, generate text, or write small pieces of code, but when it comes to building something larger—like a full mobile application—it needs structure, collaboration, and specialized roles. In many ways, this looks a lot like how human teams work. Just as people divide work between planners, workers, reviewers, and managers, AI agents can do the same by creating teams of subagents.

Think about building a mobile app. It is not just one step. First, someone needs to understand user requirements. Then there has to be a plan for the app’s architecture. After that comes coding, testing, fixing bugs, and finally publishing. A single AI model trying to do all of this at once would struggle. But a team of specialized AI roles can make the process much more organized and reliable.

The first role in almost every AI team is the doer. This is the worker that writes code, creates content, or performs tasks directly. It is like a junior developer on a human team—good at execution but not always great at seeing the bigger picture. That bigger picture usually belongs to the planner. The planner breaks down a large problem into smaller tasks. In a mobile app project, this could mean turning a simple user prompt into clear feature requirements and then designing the app’s architecture before any coding begins.

Another important role is the tool operator. AI agents often need to interact with APIs, databases, or external services. The tool operator handles those interactions. For example, if the app needs payment integration or cloud storage, this role knows how to connect to those systems. Alongside that, there is often a learner. This role gathers information from outside sources like websites, competitor apps, or user reviews. In app development, this might help the AI discover what features users expect or what trends are popular in the market.

No strong team works without feedback, and AI teams are no different. That is where the critic comes in. The critic reviews outputs, checks for errors, looks for hallucinations, and tests whether the generated code actually works. Sometimes it even compares multiple solutions and chooses the best one. Then there is the supervisor, which watches the overall workflow. If one subagent gets stuck or something fails, the supervisor steps in to keep the process moving. Finally, there is the presenter. This role takes all the pieces and communicates the final result back to the user in a clear and understandable way.

Making these roles effective depends on a few things. First is prompting—clear instructions are like good management. Second is model selection, because not every model is suited for every role. Third is fine-tuning, which can improve performance with examples. And fourth is context, giving each subagent the right information without overwhelming it.

In the end, AI agent teams are starting to look a lot like human organizations. Small teams can solve simple problems quickly, but bigger and more complex tasks require more roles, more specialization, and stronger internal collaboration. That is how modern AI moves from simple chat to real-world problem solving.