Chapter 5: Cloud Providers (AWS, Azure, GCP)

Part 1: The "Why": What is Cloud Computing?

In the previous chapters, we've learned how to write scripts, manage a Linux server, and build CI/CD pipelines. But *where* do these servers live? Ten years ago, the answer was an "on-premise" (on-prem) data center. This means your company would buy physical server hardware, put it in a cold room in your office, manage the electricity, and manage the internet connection.

This was slow, expensive, and didn't scale. If your website suddenly got 10 million users, you couldn't just "buy 1,000 new servers" instantly. You'd have to order them, wait weeks for delivery, and manually install them.

The Cloud Revolution

**Cloud Computing** (like **Amazon Web Services (AWS)**) solves this. A cloud provider is simply a company that has *already* built massive, global data centers, and they rent you their servers by the second.
Instead of buying a physical server, you make an API call (or click a button) and a new virtual server is ready for you in 30 seconds. When you're done, you make another API call to delete it, and you stop paying.

This is the foundation of DevOps. The cloud provides **on-demand, self-service, pay-as-you-go infrastructure**, which is the perfect platform for automation.

The 3 Main Service Models (IaaS, PaaS, SaaS)

"Cloud" is a general term. It's broken down into three main service models. The most famous analogy is the "Pizza as a Service" model.

1. IaaS (Infrastructure as a Service)

• The Analogy: You buy the ingredients (flour, sauce, cheese) and use the restaurant's oven.
• The Explanation: The cloud provider gives you the *raw infrastructure* (virtual servers, storage, networking). You are responsible for *everything* else: managing the OS, installing security patches, installing your database, and running your app.
• This is the primary domain of a DevOps Engineer.
• Example Services: **AWS EC2**, Azure Virtual Machines, Google Compute Engine.

2. PaaS (Platform as a Service)

• The Analogy: You just order the pizza. The restaurant handles the ingredients, oven, and cooking. You just set the table.
• The Explanation: The cloud provider manages the OS, the patching, and the runtime (e.g., the Node.js or Python environment). You *only* upload your code (e.g., your app.js file) and the platform runs it for you.
• Pros: Much easier than IaaS. No server management.
• Cons: Less flexible. You can't SSH into the server to install a custom tool.
• Example Services: **Heroku**, AWS Elastic Beanstalk, Google App Engine.

3. SaaS (Software as a Service)

• The Analogy: You go to a restaurant, sit down, and eat. You manage nothing.
• The Explanation: You are just a *user* of the software. The provider manages everything.
• Example Services: **Gmail**, **GitHub**, **Firebase**, Office 365, Dropbox.

The 3 Deployment Models (Public, Private, Hybrid)

• Public Cloud (AWS, GCP, Azure): The most common. You share the data center with other companies (this is called "multi-tenancy"). It's the cheapest and most scalable.
• Private Cloud: A private data center that a company builds *for itself*, but it runs on cloud principles (automation, self-service). Used by banks or governments with extreme security needs.
• Hybrid Cloud: A mix of both. A company might run its public website on AWS (Public Cloud) but keep its sensitive user database on-premise (Private Cloud) and connect the two.

Part 2: The "Big 3" Cloud Providers

While hundreds of cloud providers exist, the market is dominated by three giants. As a DevOps engineer, you must be familiar with at least one, and ideally all three.

1. Amazon Web Services (AWS): The undisputed market leader (around 32% market share). It has the most services, the largest community, and is the most widely used by startups and enterprises. We will focus on AWS for our deep dive.
2. Microsoft Azure: The clear #2 (around 22% market share). It is extremely popular in large corporations that already use a lot of Microsoft products (like Windows Server, .NET, and SQL Server).
3. Google Cloud Platform (GCP): The #3 (around 11% market share). It is famous for its data engineering, machine learning, and, most importantly, **Kubernetes**. Google *invented* Kubernetes (GKE - Google Kubernetes Engine) and is considered the leader in that specific area.

Part 3: Deep Dive into AWS (The Market Leader)

AWS has over 200 services. You don't need to know them all. A DevOps engineer needs to master the "core" services related to compute, storage, networking, and identity.

Core Concepts: Regions, AZs, and IAM

• Region: A physical, geographic location in the world (e.g., us-east-1 in N. Virginia, ap-south-1 in Mumbai).
• Availability Zone (AZ):** A single data center (or multiple data centers) *within* a Region. Each Region has at least 2-3 AZs.
  Why? For **High Availability**. You should run your app in *at least two* AZs. If one data center (AZ-1) has a power failure, your app will keep running in AZ-2, and your users will never know.

// This policy allows a user to READ (Get, List)
// from the "my-app-backups" S3 bucket, but nothing else.
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::my-app-backups",
                "arn:aws:s3:::my-app-backups/*"
            ]
        }
    ]
}

| Concept                | AWS (Amazon)                | Azure (Microsoft)               | GCP (Google)                |
|------------------------|-----------------------------|---------------------------------|-----------------------------|
| Virtual Server (IaaS)  | EC2 (Elastic Compute Cloud) | Azure Virtual Machines          | GCE (Google Compute Engine) |
| Object Storage         | S3 (Simple Storage Service) | Blob Storage                    | Google Cloud Storage (GCS)  |
| Virtual Network        | VPC (Virtual Private Cloud) | VNet (Virtual Network)          | VPC (Virtual Private Cloud) |
| Serverless Function    | Lambda                      | Azure Functions                 | Google Cloud Functions      |
| Relational Database    | RDS (Relational DB Service) | Azure SQL Database              | Cloud SQL                   |
| NoSQL Database         | DynamoDB                    | Cosmos DB                       | Firestore / Bigtable        |
| DNS Service            | Route 53                    | Azure DNS                       | Cloud DNS                   |
| Kubernetes             | EKS (Elastic K8s Service)   | AKS (Azure K8s Service)         | GKE (Google K8s Engine)     |
| Docker Registry        | ECR (Elastic Container Registry) | ACR (Azure Container Registry) | GCR (Google Container Registry) |
| Identity / Auth        | IAM                         | Entra ID (was Azure AD)         | Cloud IAM                   |

# 1. Configure the AWS Provider
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

# 2. Define a variable
variable "instance_type" {
  description = "The type of EC2 instance"
  type        = string
  default     = "t2.micro"
}

# 3. Define a resource (the server)
resource "aws_instance" "my_web_server" {
  ami           = "ami-0c7217cdde317cfec" # Ubuntu 22.04 AMI in us-east-1
  instance_type = var.instance_type

  tags = {
    Name = "My-Web-Server-01"
  }
}

# 1. Initialize the project (downloads the AWS provider)
$ terraform init

# 2. See what Terraform *plans* to do
$ terraform plan

Terraform will perform the following actions:
  # aws_instance.my_web_server will be created
  + resource "aws_instance" "my_web_server" { ... }
Plan: 1 to add, 0 to change, 0 to destroy.


# 3. Apply the changes
$ terraform apply

Do you want to perform these actions?
  Only 'yes' will be accepted to approve.
  
  Enter a value: yes

aws_instance.my_web_server: Creating...
aws_instance.my_web_server: Creation complete after 30s [id=i-1234567890abcdef]