Cloud Computing Concepts and Architectures

Cloud computing has transformed how we build, deploy, and scale modern applications. But for beginners, the wide range of terminology – like autoscaling, serverless, IaC, and container orchestration – can be overwhelming. This guide breaks down the most essential cloud computing concepts in simple, approachable terms, using relatable analogies and real-world examples. Whether you’re new to cloud development or just brushing up, you’ll walk away with a clear understanding of how modern cloud platforms like AWS, Azure, and Google Cloud operate behind the scenes.

From scaling strategies to storage options, event-driven designs to serverless functions, and infrastructure automation to networking principles—this post provides a comprehensive overview to help you confidently navigate the cloud ecosystem.

Scaling

Scaling means adjusting the resources (like CPU, RAM, servers) depending on the workload.

1. Vertical Scaling (Scaling Up): Think of upgrading your laptop by adding more RAM or a faster CPU. In cloud, it means increasing the size (capacity) of a single machine (e.g., more CPU/RAM to a virtual machine).
2. Horizontal Scaling (Scaling Out): Like adding more waiters to a busy restaurant instead of hiring just one expert waiter. You add more machines (instances) to share the load. Cloud providers like AWS let you run multiple copies of a service to handle increased demand.

Load Balancing

Load Balancers evenly distribute incoming network traffic across multiple servers.

1. Round Robin: Each request goes to the next server in line. Simple and fair but doesn’t consider load.
2. Least Connections / CPU Utilization: Smarter methods where traffic goes to the server with the fewest connections or lowest CPU load. Helps prevent overloading a single server.

Autoscaling

Autoscaling automatically adds or removes servers based on traffic. Example: An e-commerce site may have 2 servers on normal days, but during Black Friday, cloud services automatically spin up 20 servers to handle the load – then scale down when the traffic drops.

Serverless Computing

Serverless computing is a way to build and run applications without thinking about servers. Of course, servers still exist, but the cloud provider (like AWS) handles all the server management for you. You focus only on your code, not on provisioning, scaling, or maintaining infrastructure.

• AWS Lambda: 
  • Write a small piece of code (called a Lambda function) that performs a specific task, like resizing an image or processing a sensor reading.
  • Set up a trigger, such as a file being uploaded to S3 or a message arriving in a queue.
  • AWS automatically runs the function when the trigger occurs – no servers to manage.
  • You’re charged based on:
    • The number of times the function is invoked.
    • The time it takes to run (in milliseconds).
    • The amount of memory used.
• To run millions of functions in parallel, AWS Lambda uses several cloud-native, distributed systems concepts. This is where similarities to OpenSearch come in.
• OpenSearch (a search and analytics engine based on Elasticsearch) is designed for high performance at scale, and AWS has applied several of its underlying principles to Lambda’s serverless architecture:
  • Sharding and Partitioning: splits large datasets across shards and nodes for faster querying
  • Stateless Execution: handles each query independently, without remembering previous queries (stateless).
  • On-Demand Resource Allocation: spins up or pulls resources only when needed, optimizing memory and compute usage.
  • Multitenancy and Isolation: uses container-level isolation for each function invocation, allowing secure, parallel, and multi-tenant execution
  • Elastic Scaling and Load Distribution: distributes queries across nodes to handle millions of requests.

Event-Driven Architecture

This architecture responds to events (like a file being uploaded, a message sent, etc.).

1. Tight Coupling vs Loose Coupling: In tight coupling, components depend heavily on each other (harder to scale/maintain). Event-driven systems are loosely coupled – components communicate via events and don’t know each other directly.
2. SNS (Simple Notification Service) and EventBridge: These are messaging services:
   • A Publisher sends a message/event.
   • A Subscriber receives and acts on it.
   • Example: When a photo is uploaded to S3, EventBridge can trigger a Lambda function to create a thumbnail.

Container Orchestration

Containers package an app and its environment into one portable unit (using tools like Docker).

1. Isolated Environment Bundle: Each container has its own filesystem and runs independently. Think of it like running apps in separate sandboxes.
2. Handling Overuse / Failures: Systems like Kubernetes monitor the containers. If one fails, it restarts it. If a container uses too many resources, it throttles or scales out.
3. ECS (Elastic Container Service) and EKS (Elastic Kubernetes Service): AWS services for running containers with features like load balancing, auto-healing, and monitoring.

Cloud Storage

Different types of storage for different needs:

1. Object Storage (e.g., Amazon S3): Best for storing files: images, videos, documents, JSONs. Highly scalable and durable.
2. Block Storage (e.g., Amazon EBS): Acts like a hard drive. You can attach it to a server and run databases or ML models. You can increase/decrease size as needed.
3. Databases: 
   • Relational: SQL-based like PostgreSQL or MySQL (structured data).
   • NoSQL:
     • Document-based: MongoDB
     • Key-value: DynamoDB
     • Search engine: OpenSearch/Elasticsearch
     • Graph: Neo4j, Amazon Neptune
4. Cache: Redis, Memcached — used for speeding up data access.

Cloud Availability

Availability refers to how reliably your application or service stays online and accessible to users. It’s one of the most critical aspects of cloud computing—especially for businesses that depend on their applications being reachable 24/7.

• We measure availability as a percentage of uptime over a given time period (usually a year).
  • “Three Nines” (99.9%) means less than 8.76 hours of downtime per year.
  • “Five Nines” (99.999%) means less than 6 minutes of downtime per year. That’s extremely reliable – and it’s what major cloud providers aim to offer.
• Cloud providers use multiple strategies to keep your services running with minimal disruption:
  • Horizontal scaling (more servers)
  • Redundancy across multiple Availability Zones (geographic regions)
  • Auto-healing and Monitoring
  • Load Balancers
  • Disaster Recovery and Backups

Durability

Durability is about not losing data over time.

1. Services like Amazon S3 make multiple copies of your data in different locations.
2. Even if one server or data center fails, your data is safe.

Infrastructure as Code (IaC)

IaC means writing code to set up and manage cloud infrastructure. It brings the benefits of automation, repeatability, and version control to infrastructure setup.

• Why it matters: Doing setup manually through UI or console is error-prone and hard to replicate. IaC makes it reproducible and version-controlled.
• Tools:
  • CloudFormation: AWS-specific YAML/JSON templates. However, it can be verbose and hard to manage for complex setups.
  • CDK (Cloud Development Kit): Uses real programming languages (Python, TypeScript) to define infrastructure.
  • Terraform: 
    • Cloud-agnostic tool that supports AWS, Azure, Google Cloud, and others.
    • Uses its own declarative language (HCL – HashiCorp Configuration Language).
    • You define what the infrastructure should look like, and Terraform handles the rest.

Cloud Networks

Cloud networking allows secure, scalable, and isolated communication between cloud resources.

1. Traditional Concepts
   • Subnets: Smaller networks within a larger one.
   • Security Groups: Firewalls controlling access to servers.
2. Cloud-specific Isolation: You can isolate different apps into Virtual Private Clouds (VPCs) with their own rules, access control, and routing tables.