Cloud Computing, Fall 2025 Semester

This repository contains the source code, scripts, and documentation for a Cloud Computing learning project, developed in Ubuntu Linux using command-line tools and cloud platforms. The project is structured as a series of weekly labs to build foundational skills in cloud concepts and deployment. Git and GitHub usage begins from Week 03 for version control and repository management.

Project Overview

Path: /home/deepblue/cloud_computing
Environment: Ubuntu Linux (e.g., VirtualBox VM), Python (Flask), Heroku CLI, OpenSSH, Vagrant
Purpose: Learn cloud computing fundamentals through hands-on labs, with outputs verified via terminal logs and cloud dashboards.
Structure: Weekly scripts and command histories called in lab sessions to demonstrate concepts.

Week 01: Course Introduction and Cloud Computing Overview

Objectives

Understand the syllabus, tools, and basic terminology.
Gain an overview of cloud computing history, benefits, and key players (e.g., AWS, Azure, Google Cloud).

Content

Reviewed course outline: Focus on service models, deployment strategies, and hands-on deployments.
Explored core concepts: Scalability, elasticity, virtualization, and economic models.

Week 02: Cloud Service Models

Objectives

Differentiate between service models: IaaS (Infrastructure as a Service), CaaS (Container as a Service), PaaS (Platform as a Service), FaaS (Function as a Service), and SaaS (Software as a Service).
Understand responsibilities, use cases, and trade-offs for each model.

Content

week02_service_models.md (or notes in Markdown):
- IaaS: Full control over OS and apps (e.g., AWS EC2); user manages runtime, middleware, and data.
- CaaS: Container orchestration (e.g., Kubernetes on Google Cloud); abstracts infrastructure but manages containers.
- PaaS: Managed platform for app deployment (e.g., Heroku); handles runtime and middleware.
- FaaS: Serverless execution (e.g., AWS Lambda); pay-per-use, no server management.
- SaaS: Fully managed apps (e.g., Google Workspace); end-user consumption only.
- Example: Diagram or table summarizing models (e.g., responsibility matrix).
Hands-on Lab: PaaS Deployment with Heroku and Flask:
- Created a simple Flask app (app.py):
```
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from PaaS on Heroku!"

if __name__ == '__main__':
    app.run()
```
- Created a requirments.txt file and a Procfile file.
- Prepared for deployment (full Git-based push covered in Week 03): heroku create flask-hello-paas.

Week 03: Cloud Deployment Models

Objectives

Explore deployment strategies: Public, Private, Hybrid, and Community clouds.
Understand security, compliance, and scalability implications.
Introduce Git and GitHub for version control, including repository setup and basic commands.

Content

week03_deployment_models.md (summary notes):
- Public: Shared resources (e.g., AWS public cloud); cost-effective but less control.
- Private: Dedicated infrastructure (e.g., on-premises VMware); high security for sensitive data.
- Hybrid: Mix of public/private (e.g., burst to public during peaks); best for flexibility.
- Community: Shared by specific groups (e.g., government clouds); balances cost and compliance.
- Example: Use case scenarios, like a bank using hybrid for core vs. analytics workloads.
Hands-on Lab: IaaS Part 1 - OpenSSH Setup:
- Installed OpenSSH server: sudo apt update && sudo apt install openssh-server -y.
- Configured: Started service (sudo systemctl start ssh).
- Tested: From local terminal, ssh deepblue@localhost (or remote VM IP).
- Captured history: history >> command.txt.
Git and GitHub Introduction:
- Installed Git: sudo apt install git -y.
- Configured identity: git config --global user.name "Your Name" and git config --global user.email "your.email@example.com".
- Initialized repository: git init, added files (git add .), committed (git commit -m "Initial commit"), and pushed to GitHub (git remote add origin <repo-url> && git push -u origin main).

Week 04: Data Centers and Cloud Architecture

Objectives

Understand physical and logical data center infrastructure components.
Learn about server hardware, networking, cooling, and power management.
Explore virtualization technologies and cloud architecture patterns.
Study scalability, fault tolerance, and geographic distribution of cloud services.

Content

Theory: Data Centers and Cloud Architecture:
- Data center components: Servers, storage, networking equipment, cooling systems, power distribution.
- Virtualization concepts: Hypervisors, virtual machines, resource allocation and management.
- Cloud architecture patterns: Multi-tier architectures, microservices, load balancing, auto-scaling.
- Geographic distribution: Availability zones, regions, content delivery networks (CDN).
- Fault tolerance: Redundancy, backup systems, disaster recovery planning.
Hands-on Lab: IaaS with Vagrant - Web Server Deployment:
- Environment Setup: Used Vagrant with VirtualBox to create reproducible IaaS environment.
- Configuration Files:
  - Vagrantfile: Configured Ubuntu 24.04 VM with 2GB RAM, 2 CPUs, port forwarding (80→8080).
  - bootstrap.sh: Shell provisioning script for automated Apache installation and configuration.
  - index.html: Simple web content to verify successful deployment.
- Key Features Implemented:
  - VM Configuration:
```
config.vm.box = "bento/ubuntu-24.04"
config.vm.provider "virtualbox" do |vb|
  vb.name = "IaaS-WebServer"
  vb.memory = "2048"
  vb.cpus = 2
end
```
  - Network Setup: Port forwarding and private network configuration.
  - Automated Provisioning: Apache web server installation and configuration.
  - Shared Folders: Synchronization between host and guest systems.
- Deployment Process:
  1. vagrant up: Launch and provision VM automatically.
  2. Access web server via http://localhost:8080 or http://192.168.33.10.
  3. Verify deployment with custom HTML content.
  4. vagrant destroy: Clean up resources when done.
- Learning Outcomes:
  - Demonstrated IaaS concepts through hands-on VM management.
  - Understood infrastructure provisioning and automation.
  - Experienced web server deployment in virtualized environment.
  - Learned about network configuration and port forwarding in cloud contexts.

Week 05: Virtualization

Objectives

Understand and explain the concepts and types of virtualization
Analyze CPU, memory, network, and storage virtualization technologies
Compare characteristics and differences of major hypervisors
Evaluate advantages, disadvantages, and performance considerations of virtualization technologies
Build and manage virtualized environments

Content

Theory: Virtualization Technologies:
- Virtualization Fundamentals: Hardware abstraction, resource pooling, isolation principles.
- Hypervisor Types:
  - Type 1 (Bare-metal): VMware ESXi, Microsoft Hyper-V, Citrix XenServer.
  - Type 2 (Hosted): VMware Workstation, Oracle VirtualBox, Parallels Desktop.
- Virtualization Techniques:
  - Hardware-assisted virtualization (Intel VT-x, AMD-V).
- Resource Management: CPU virtualization, memory virtualization, network virtualization, storage virtualization.
- Virtual Machine Lifecycle: Creation, deployment, migration, snapshotting, backup and recovery.
- Performance Considerations: Overhead analysis, optimization techniques, resource contention.
Hands-on Lab: Inline Vagrant Provisioning with Arch Linux:
- Simple VM Configuration: Used streamlined Vagrant setup with inline provisioning.
- Configuration Features:
```
Vagrant.configure("2") do |config|
  config.vm.box = "dreamscapes/archlinux"
  config.vm.network "forwarded_port", guest: 22, host: 2221
  config.vm.provision "shell", inline: <<-SHELL
    echo "Hello~ IaaS: Provisioned!" >> /home/vagrant/hello.txt
    sudo pacman -Sy --noconfirm nano
  SHELL
end
```
- Key Learning Points:
  - Simplified Provisioning: Demonstrated inline shell provisioning without separate script files.
  - Alternative OS: Used Arch Linux instead of Ubuntu to show cross-platform virtualization.
  - Port Forwarding: SSH port mapping (22→2221) for remote access configuration.
  - Package Management: Arch Linux's pacman package manager usage in automated setup.
  - File System Operations: Automated file creation and text editor installation.
- Deployment Process:
  1. vagrant up: Launch Arch Linux VM with inline provisioning.
  2. vagrant ssh: Connect using custom SSH port (2221).
  3. Verify provisioning: Check /home/vagrant/hello.txt file creation.
  4. Test installed software: Use nano text editor.
  5. vagrant halt and vagrant destroy: Lifecycle management practice.
- Learning Outcomes:
  - Experienced different Linux distributions in virtualized environments.
  - Understood inline vs. external provisioning script approaches.
  - Practiced VM lifecycle management and SSH connectivity.
  - Learned cross-platform package management in automated deployments.
  - Demonstrated virtualization portability across different guest operating systems.

Week 06: Container Technology and Docker

Objectives

Understand container technology concepts and differences from virtual machines
Explain Docker architecture and core components
Manage Docker image and container lifecycle
Practice Docker networking and data management with volumes

Content

Theory: Container Technology and Docker:
- Container Technology Overview:
  - Containers package applications and dependencies into isolated environments using OS-level virtualization.
  - Emerged to solve the "it works on my machine" problem with environment consistency.
  - Key Motivations: Environment consistency, dependency management, deployment efficiency, resource efficiency.
- Containers vs Virtual Machines:
  - VM Architecture: Physical Server → Hypervisor → Complete Guest OS per VM → Applications
  - Container Architecture: Physical Server → Host OS → Container Runtime → Applications
  - Performance Comparison: Containers achieve 78% resource utilization vs. 42% for VMs, with 28% higher throughput and 37% lower latency.
  - Startup Time: Containers start in 1-2 seconds vs. several minutes for VMs.
- Docker Architecture:
  - Client-Server Architecture with REST API communication:
    - Docker Client (CLI): User interface for Docker interaction
    - Docker Daemon (dockerd): Manages Docker objects (images, containers, networks, volumes)
    - Container Runtime: containerd (high-level) + runc (low-level execution)
  - Docker Objects:
    - Images: Read-only templates with layered structure for efficient storage
    - Containers: Runnable instances of images with isolated processes
    - Registry: Services for storing and distributing images (Docker Hub, AWS ECR)
- Docker Image Layer System:
  - Each Dockerfile instruction creates a new layer
  - Layer Characteristics: Immutability, incremental changes, shareability
  - Union Filesystem: Combines multiple layers using overlay2 storage driver
  - Optimization Techniques: Multi-stage builds, layer caching, lightweight base images (Alpine Linux)
- Docker Networking:
  - Bridge Network (Default): Isolated private network with NAT for external communication
  - Host Network: Direct use of host's network stack for best performance but no isolation
  - None Network: Complete network isolation for security-critical workloads
  - Overlay Network: Multi-host communication using VXLAN tunnels
- Docker Volumes and Data Management:
  - Volumes (Recommended): Docker-managed storage in /var/lib/docker/volumes/
  - Bind Mounts: Direct host directory mounting for development
  - tmpfs Mounts: Memory-based storage for temporary data
  - Use Cases: Database persistence, log collection, configuration sharing
- Container Registry:
  - Public: Docker Hub with official certified images
  - Private: AWS ECR, Google GCR, Azure ACR, Harbor
  - Security: Image scanning, RBAC, Docker Content Trust for signing
Hands-on Lab: Docker Installation and Basic Operations:
- Docker Installation on Ubuntu (docker-install-ubuntu.md):
  - Removed existing Docker packages to avoid conflicts
  - Set up official Docker repository with GPG key authentication
  - Installed Docker Engine components: docker-ce, docker-ce-cli, containerd.io, docker-buildx-plugin, docker-compose-plugin
  - Configured Docker service and enabled auto-start on boot
  - Added user to docker group for non-root access
- Basic Docker Commands:
```
# Test installation
docker run hello-world

# Image management
docker pull nginx:alpine
docker images
docker rmi <image-id>

# Container lifecycle
docker run -d -p 8080:80 --name web nginx:alpine
docker ps
docker stop web
docker start web
docker rm web

# Logs and debugging
docker logs web
docker exec -it web /bin/sh

# System cleanup
docker system prune -a
```
- Learning Outcomes:
  - Successfully installed and configured Docker on Ubuntu
  - Understood Docker architecture through practical commands
  - Managed image and container lifecycle operations
  - Practiced port mapping and container networking basics
  - Experienced container isolation and resource management

Week 07: Container Orchestration with Docker Compose and Kubernetes

Objectives

Configure multi-container applications using Docker Compose and understand its limitations
Explain the necessity and basic concepts of Kubernetes
Understand Kubernetes cluster architecture
Describe core Kubernetes objects like Pod, Service, and Deployment
Perform basic Kubernetes operations using MiniKube and kubectl

Content

Theory: Docker Compose and Kubernetes:
- Docker Compose Basics:
  - Tool for defining and running multi-container applications
  - Need: Modern apps consist of web servers, databases, caches, message queues, and load balancers
  - docker-compose.yml Structure:
    - services: Container definitions
    - volumes: Data persistence
    - networks: Inter-service communication
    - Service options: image, build, ports, environment, depends_on, volumes
  - Workflow: Development (service definition → execution → testing) and Production (configuration → scaling → updates → monitoring)
- Docker Compose Limitations:
  - Single Host Constraints: Limited scalability and no high availability
  - Production Limitations: Manual recovery, limited load balancing, basic deployment strategies
  - Monitoring: Limited metrics and observability, simple health checks
- Introduction to Kubernetes (K8s):
  - Open-source platform for automating containerized application deployment, scaling, and management
  - Originally developed by Google, now managed by CNCF
  - Problems Solved: Service discovery, load balancing, self-healing, declarative configuration
  - Core Concepts:
    - Declarative Management: Define desired state → Monitor current state → Automatic adjustment
    - Controller Pattern: Continuous monitoring → Detect differences → Adjustment actions
- Kubernetes Architecture:
  - Control Plane (Master Node):
    - API Server: Cluster frontend with RESTful API, authentication/authorization
    - etcd: Distributed key-value store for cluster state using RAFT algorithm
    - Scheduler: Pod placement decisions based on resources and constraints
    - Controller Manager: Runs controllers to maintain desired state
  - Worker Node:
    - kubelet: Node agent for Pod management and status reporting
    - kube-proxy: Network proxy for Service abstraction and load balancing
    - Container Runtime: Docker, containerd, CRI-O for container execution
- Kubernetes Core Objects:
  - Pod:
    - Smallest deployable unit containing one or more containers
    - Shared network and storage within Pod
    - Ephemeral nature with unique cluster IP
    - Patterns: Single container (most common), Multi-container (sidecar pattern)
  - Service:
    - Abstracts network access to Pods (handles dynamic IP changes)
    - Types:
      - ClusterIP: Internal cluster access only (default)
      - NodePort: External access through node ports
      - LoadBalancer: Cloud provider integration for external traffic
  - Deployment:
    - Provides declarative updates for Pods and ReplicaSets
    - Functions: Replica management, rolling updates, rollback, scaling
    - Manages ReplicaSets which create and manage actual Pods
- MiniKube and kubectl:
  - MiniKube: Single-node cluster for local development and learning
  - kubectl: CLI tool with syntax: kubectl [command] [TYPE] [NAME] [flags]
- Kubernetes vs Docker Compose Comparison:
  - Docker Compose Suitable For: Development, small apps, prototyping, CI/CD
  - Kubernetes Suitable For: Production, microservices, high availability, multi-cloud
  - Technical Differences: Complexity, scalability, availability capabilities

Hands-on Lab Part 1: Docker Compose Multi-Container Application (docker_compose.txt):

Project Setup:
- Created directory structure with docker-compose.yml and custom HTML
- Defined multi-service architecture with networking and data persistence

Service Configuration:

services:
  web:
    image: nginx:alpine
    ports: ["8080:80"]
    volumes: ["./html:/usr/share/nginx/html:ro"]
    depends_on: [db]
  
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes: [db_data:/var/lib/postgresql/data]
  
  redis:
    image: redis:alpine

volumes:
  db_data:

networks:
  app-net:
    driver: bridge

Operations Practiced:

# Start multi-container application
docker compose up -d

# Check service status
docker compose ps

# View logs
docker compose logs web

# Database connection test
docker compose exec db psql -U admin -d myapp

# Scale services
docker compose up -d --scale web=2

# Cleanup
docker compose down -v

Learning Outcomes:
- Configured complex multi-container applications declaratively
- Understood service dependencies and networking
- Practiced volume management for data persistence
- Experienced service scaling and inter-service communication

Hands-on Lab Part 2: Kubernetes with MiniKube (kubectl-minikube-install-ubuntu.md, my-pod.yaml):

Installation Process:

kubectl Installation:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
kubectl version --client

MiniKube Installation:

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/
minikube version

Cluster Startup:

minikube start --driver=docker
minikube status
kubectl cluster-info
kubectl get nodes

Basic Kubernetes Operations:

Created Pod definition (my-pod.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: web-pod
  labels:
    app: web
spec:
  containers:
  - name: web-container
    image: nginx:1.21
    ports:
    - containerPort: 80

kubectl Commands Practiced:

# Pod management
kubectl apply -f my-pod.yaml
kubectl get pods
kubectl describe pod web-pod
kubectl logs web-pod
kubectl delete pod web-pod

# Imperative Pod creation
kubectl run test-pod --image=nginx:1.21

# Cluster management
minikube dashboard
minikube stop
minikube start

Troubleshooting:
- Configured Docker group permissions for non-root access
- Handled MiniKube startup failures with service restarts
- Used minikube delete --all --purge for clean reinstallation
Learning Outcomes:
- Successfully set up local Kubernetes development environment
- Understood Kubernetes object model through YAML definitions
- Practiced declarative (YAML) and imperative (CLI) Pod management
- Experienced cluster lifecycle management with MiniKube
- Verified Kubernetes concepts learned in theory through hands-on practice
- Prepared foundation for production-grade orchestration concepts

Technologies and Tools Used

Version Control: Git, GitHub
Cloud Platforms: Heroku (PaaS)
Virtualization: VirtualBox, Vagrant
Containers: Docker, Docker Compose
Orchestration: Kubernetes, MiniKube, kubectl
Operating Systems: Ubuntu 24.04, Arch Linux
Web Servers: Apache, Nginx
Databases: PostgreSQL
Caching: Redis
Programming: Python (Flask), Shell scripting

Learning Path Summary

Weeks 1-2: Cloud fundamentals and service models
Week 3: Deployment models and version control with Git
Weeks 4-5: Infrastructure concepts through virtualization
Week 6: Container technology and Docker fundamentals
Week 7: Multi-container apps and Kubernetes orchestration
Week 8: Midterm Exam

Name		Name	Last commit message	Last commit date
week03		week03
week04/vagrant-apache		week04/vagrant-apache
week05/vagrant-arch-lab		week05/vagrant-arch-lab
week06		week06
week07		week07
week09		week09
week10		week10
week11		week11
week12		week12
week14		week14
README.md		README.md

Navigation Menu

Repository navigation

About

Repository files navigation

Cloud Computing, Fall 2025 Semester

Project Overview

Week 01: Course Introduction and Cloud Computing Overview

Objectives

Content

Week 02: Cloud Service Models

Objectives

Content

Week 03: Cloud Deployment Models

Objectives

Content

Week 04: Data Centers and Cloud Architecture

Objectives

Content

Week 05: Virtualization

Objectives

Content

Week 06: Container Technology and Docker

Objectives

Content

Week 07: Container Orchestration with Docker Compose and Kubernetes

Objectives

Content

Technologies and Tools Used

Learning Path Summary

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Cloud Computing, Fall 2025 Semester

Project Overview

Week 01: Course Introduction and Cloud Computing Overview

Objectives

Content

Week 02: Cloud Service Models

Objectives

Content

Week 03: Cloud Deployment Models

Objectives

Content

Week 04: Data Centers and Cloud Architecture

Objectives

Content

Week 05: Virtualization

Objectives

Content

Week 06: Container Technology and Docker

Objectives

Content

Week 07: Container Orchestration with Docker Compose and Kubernetes

Objectives

Content

Technologies and Tools Used

Learning Path Summary

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages