Mastering Deployment of AI Pipelines 

Below you will find some suggested materials on these topics, which we believe may help you complete the final activity in the lesson. Please note that using these resources is entirely optional, and you are welcome to explore any other sources or courses at your own discretion.

Opening Statement:

• Welcome to this session on Cloud Deployment Tools and Strategies.

• In today’s lecture, we will explore how to deploy Dockerized applications using cloud tools like AWS Lambda and Kubernetes while ensuring scalability and reliability.

Agenda:

1. Overview of popular cloud deployment tools: AWS Lambda, Kubernetes, and others.

2. Steps to deploy a Dockerized application to AWS Lambda.

3. Strategies for scalability and reliability: load balancing and monitoring.

Part 1: Overview of Cloud Deployment Tools (5 Minutes)

Key Cloud Deployment Tools:

1. AWS Lambda:

   • What it is: A serverless compute service that automatically runs code in response to events.

   • Advantages:

     • No need to manage servers.

     • Scales automatically with usage.

     • Cost-efficient for event-driven workloads.

   • Use Case: Running backend tasks or microservices without maintaining infrastructure.

2. Kubernetes:

   • What it is: An open-source platform for automating deployment, scaling, and management of containerized applications.

   • Advantages:

     • Orchestrates multiple containers across nodes.

     • Handles scaling and self-healing (e.g., restarting failed containers).

   • Use Case: Managing large-scale, complex applications with multiple services.

3. Other Tools:

   • AWS ECS (Elastic Container Service): Simplifies container orchestration for smaller workloads.

   • Google Cloud Run: Fully managed compute platform for containerized applications.

Comparison Table:  CLICK HERE 

Part 2: Deploying a Dockerized Application to AWS Lambda (7 Minutes)

Step 1: Create and Package the Application

Build the Application: Write a simple FastAPI application.
python
Copy code
from fastapi import FastAPI

app = FastAPI()

@app.get("/")

def read_root():

    return {"message": "Hello, AWS Lambda"}

Create a Dockerfile:
dockerfile
Copy code
FROM public.ecr.aws/lambda/python:3.9

# Copy application files

COPY app/ /var/task

# Command for AWS Lambda to execute

CMD ["app.main.handler"]

Build and Package:
bash
Copy code
docker build -t lambda-docker .

docker save lambda-docker > lambda-docker.tar

Step 2: Deploy the Application

Push the Image to AWS Elastic Container Registry (ECR):
bash
Copy code
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your_ecr_repository>

docker tag lambda-docker <your_ecr_repository>:latest

docker push <your_ecr_repository>:latest

1. 
   

2. Create an AWS Lambda Function:

   • In the AWS Management Console:

     • Navigate to Lambda → Create Function → Use a Container Image.

     • Select the image from ECR.

3. Test the Lambda Function:

   • Use the AWS Console to trigger the function.

   • Verify the output in the logs.

Step 3: Access the Deployed Application

• Set up an API Gateway to expose the Lambda function via an HTTP endpoint.

Test the endpoint:
bash
Copy code
curl https://<api_gateway_url>

Part 3: Ensuring Scalability and Reliability (6 Minutes)

Scalability Strategies:

1. Auto-scaling:

   • AWS Lambda automatically scales based on the number of incoming requests.

   • Kubernetes scales pods based on resource usage metrics (CPU, memory).

2. Load Balancing:

   • For Kubernetes:

     • Use a Service with type LoadBalancer.

   • For AWS Lambda:

     • API Gateway acts as a load balancer, distributing requests to multiple Lambda instances.

Reliability Strategies:

1. Monitoring:

   • Use CloudWatch for AWS Lambda to track performance metrics like:

     • Invocation count.

     • Error rate.

     • Duration.

   • Use Prometheus and Grafana for Kubernetes to visualize pod health and resource usage.

2. Self-healing Mechanisms:

   • Kubernetes automatically restarts failed pods.

   • AWS Lambda retries failed executions.

Example Workflow for Kubernetes:

• Deploy a Dockerized application using a Kubernetes Deployment.

Use kubectl commands to manage pods and monitor scaling:
bash
Copy code
kubectl apply -f deployment.yaml

kubectl get pods

Conclusion and Key Takeaways (3 Minutes)

Recap:

1. AWS Lambda and Kubernetes are powerful tools for deploying and managing Dockerized applications.

2. Deploying a Dockerized application to AWS Lambda involves:

   • Building the container.

   • Pushing it to ECR.

   • Linking it to an API Gateway for public access.

3. Scalability and reliability can be ensured with:

   • Auto-scaling.

   • Load balancing.

   • Comprehensive monitoring tools.

Call to Action:

• Experiment with deploying your Dockerized applications using both AWS Lambda and Kubernetes.

• Explore monitoring tools like CloudWatch, Prometheus, and Grafana.

• Optimize your applications for performance and reliability.

Suggestions for Visual Aids:

1. 1. Slide 1: Comparison table of AWS Lambda, Kubernetes, and ECS.

   2. Slide 2: Diagram showing the flow of deployment to AWS Lambda.

   3. Slide 3: Kubernetes workflow for deploying and scaling applications.

   4. Slide 4: Graphs showing CloudWatch and Prometheus monitoring metrics.

Objective

By the end of this activity, you will:

1. Deploy the Dockerized Jarvid API to AWS Lambda using the Serverless Framework.

2. Test the deployed API using Postman or curl.

Step-by-Step Instructions

Step 1: Prerequisites

Install Serverless Framework: Install the Serverless Framework CLI globally.
bash
Copy code
npm install -g serverless

Install AWS CLI: Ensure the AWS CLI is installed and configured with appropriate credentials.
bash
Copy code
aws configure

2. Set Up AWS IAM Role:

   • Ensure your AWS account has permissions to create Lambda functions, API Gateway endpoints, and ECR repositories.

Docker Installed: Verify Docker is installed and running on your local machine.
bash
Copy code
docker --version

Step 2: Prepare the Jarvid API

Directory Structure:
plaintext
Copy code

jarvid-api/

├── app/

│   ├── main.py

├── requirements.txt

├── Dockerfile

├── serverless.yml

Application Code: File: app/main.py
python
Copy code

from fastapi import FastAPI

app = FastAPI()

@app.get("/")

def read_root():

    return {"message": "Hello, AWS Lambda"}

@app.get("/health")

def health_check():

    return {"status": "Healthy"}

Dockerfile: File: Dockerfile
dockerfile
Copy code

FROM public.ecr.aws/lambda/python:3.9

# Copy application files

COPY app/ /var/task

# Command for AWS Lambda to execute

CMD ["app.main.handler"]

Step 3: Configure the Serverless Framework

Create the serverless.yml Configuration File: File: serverless.yml
yaml
Copy code

service: jarvid-api

provider:

  name: aws

  runtime: python3.9

  region: us-east-1

functions:

  api:

    image:

      name: jarvid-api

      uri: <your_ecr_repository_uri>

1. Push the Docker Image to ECR:

Build the Docker image:
bash
Copy code
docker build -t jarvid-api .

Tag the image for ECR:
bash
Copy code
docker tag jarvid-api:latest <your_ecr_repository_uri>:latest

Push the image to ECR:
bash
Copy code
docker push <your_ecr_repository_uri>:latest

Deploy Using Serverless Framework: Run the deployment command:
bash
Copy code
serverless deploy

Step 4: Test the Deployed API

1. Obtain the API Gateway URL:

   • After deployment, the Serverless Framework will output the API Gateway URL.

2. Test the API with Postman:

   • Create a GET request in Postman with the API URL:

     • URL: https://<api_gateway_url>/

     • Response: { "message": "Hello, AWS Lambda" }

3. Test the API with curl:

Test the root endpoint:
bash
Copy code
curl https://<api_gateway_url>/

Expected Response:
json
Copy code
{"message": "Hello, AWS Lambda"}

Test the health check endpoint:
bash
Copy code
curl https://<api_gateway_url>/health

Expected Response:
json
Copy code
{"status": "Healthy"}

Step 5: Debugging Common Issues

1. Error: "Permission Denied":

   • Ensure your AWS IAM role has permissions to create and manage Lambda and ECR resources.

2. API Not Responding:

   • Verify the serverless.yml configuration for the correct ECR URI and function definition.

3. Deployment Errors:

Check logs using the Serverless Framework:
bash
Copy code
serverless logs -f api

Expected Outcomes

1. Deployed API:

   • The Jarvid API is successfully deployed to AWS Lambda and accessible via API Gateway.

2. Tested Endpoints:

   • All endpoints (/ and /health) respond with the expected outputs when tested with Postman or curl.

3. Scalable Serverless Application:

   • The application scales automatically with demand, leveraging AWS Lambda’s capabilities.

Objective

By the end of this activity, you will:

1. Create a script to automate the deployment of the Dockerized Jarvid API to AWS Lambda using the Serverless Framework.

2. Simplify repetitive tasks like building the Docker image, pushing it to ECR, and deploying the Serverless service.

Step-by-Step Instructions

Step 1: Prerequisites

1. Ensure Dependencies Are Installed:

   • Docker

   • AWS CLI

   • Serverless Framework

2. Validate Environment Configuration:

Confirm AWS credentials are set up using:
bash
Copy code
aws configure

Verify that Docker is running:
bash
Copy code
docker --version

3. Create Necessary Files:

   • Ensure the Dockerfile, serverless.yml, and application code are ready as defined in previous steps.

Step 2: Write the Deployment Script

File: deploy.sh

bash

Copy code

#!/bin/bash

# Variables

SERVICE_NAME="jarvid-api"

REGION="us-east-1"

ECR_URI="<your_ecr_repository_uri>" # Replace with your ECR URI

IMAGE_NAME="jarvid-api"

# Step 1: Build the Docker image

echo "Building the Docker image..."

docker build -t $IMAGE_NAME .

# Step 2: Tag the Docker image for ECR

echo "Tagging the Docker image for ECR..."

docker tag $IMAGE_NAME:latest $ECR_URI:latest

# Step 3: Push the Docker image to ECR

echo "Pushing the Docker image to ECR..."

aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ECR_URI

docker push $ECR_URI:latest

# Step 4: Deploy using the Serverless Framework

echo "Deploying the service with Serverless Framework..."

sls deploy --verbose

# Step 5: Output the API Gateway URL

echo "Retrieving the API Gateway URL..."

API_URL=$(sls info --verbose | grep "endpoints:" | awk '{print $2}')

echo "API Gateway URL: $API_URL"

# Step 6: Test the deployment (optional)

read -p "Would you like to test the deployed API? (y/n): " TEST_API

if [ "$TEST_API" == "y" ]; then

  echo "Testing the API root endpoint..."

  curl "$API_URL/"

  echo

  echo "Testing the API health endpoint..."

  curl "$API_URL/health"

fi

echo "Deployment completed successfully!"

Step 3: Make the Script Executable

1. Save the script as deploy.sh in your project directory.

Make it executable:
bash
Copy code
chmod +x deploy.sh

Step 4: Run the Deployment Script

Execute the script:
bash
Copy code
./deploy.sh

1. Follow the prompts:

   • The script will:

     • Build the Docker image.

     • Push it to ECR.

     • Deploy the service using Serverless Framework.

     • Display the API Gateway URL.

Step 5: Debugging Common Issues

1. ECR Login Issues:

   • If you encounter unauthorized errors, ensure your AWS CLI credentials have the necessary ECR permissions.

2. API Deployment Fails:

   • Check the serverless.yml configuration for any errors.

View logs using the Serverless Framework:
bash
Copy code
sls logs -f api

3. Script Permission Denied:

Ensure the script is executable:
bash
Copy code
chmod +x deploy.sh

Expected Outcomes

1. Automated Deployment:

   • The entire deployment process, including Docker image creation, ECR push, and Lambda deployment, is automated.

2. Deployed and Accessible API:

   • The API Gateway URL is displayed, and the API is live.

3. Test Results:

   • The API root (/) and health check (/health) endpoints return the expected responses when tested.

Next Steps

• Extend the script to include rollback functionality in case of deployment failures.

• Integrate the script with a CI/CD pipeline using tools like GitHub Actions or Jenkins.

• Add monitoring and logging automation using AWS CloudWatch.