DEV Community: ARAFAT O. OLAYIWOLA

Deploying and Managing Containers with AWS ECS and Fargate

ARAFAT O. OLAYIWOLA — Tue, 22 Jul 2025 16:06:55 +0000

A Technical Walkthrough: Deploying and Managing Containers with AWS ECS and Fargate

Containers are the backbone of modern cloud-native applications, offering portability, scalability, and efficiency. AWS provides multiple container orchestration tools, but in this walkthrough, we’ll focus on Amazon Elastic Container Service (ECS) with AWS Fargate, showcasing how to deploy and manage a containerized application step-by-step.

Prerequisites

Before diving into the walkthrough, ensure you have the following:

An AWS account with admin permissions.
The AWS CLI installed and configured.
Docker installed for building container images.
Basic knowledge of containers and Docker.

Step 1: Build and Push Your Docker Image to Amazon ECR

1.1: Create a Dockerfile

Let’s create a simple Dockerfile for a Python web application using Flask:

# Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Copy application files
COPY requirements.txt requirements.txt
COPY app.py app.py

# Install dependencies
RUN pip install -r requirements.txt

# Expose the application port
EXPOSE 5000

# Define the command to run the application
CMD ["python", "app.py"]

1.2: Build and Tag the Image

Run the following commands in your terminal:

docker build -t flask-app .

1.3: Push the Image to Amazon ECR

Create a Repository:

   aws ecr create-repository --repository-name flask-app

Authenticate Docker to ECR:

   aws ecr get-login-password --region <your-region> | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<your-region>.amazonaws.com

Tag the Image:

docker tag flask-app:latest <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/flask-app:latest

Push the Image:

docker push <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/flask-app:latest

Step 2: Create an ECS Cluster

Create the Cluster:

   aws ecs create-cluster --cluster-name flask-cluster

Verify the Cluster:

   aws ecs list-clusters

Step 3: Define a Task Definition

A task definition specifies how containers should run in ECS.

Create a Task Definition JSON File: Save the following as task-definition.json:

{
  "family": "flask-task",
  "networkMode": "awsvpc",
  "executionRoleArn": "arn:aws:iam::<your-account-id>:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "flask-container",
      "image": "<your-account-id>.dkr.ecr.<your-region>.amazonaws.com/flask-app:latest",
      "memory": 512,
      "cpu": 256,
      "essential": true,
      "portMappings": [
        {
          "containerPort": 5000,
          "hostPort": 5000
        }
      ]
    }
  ],
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512"
}

Register the Task Definition:

   aws ecs register-task-definition --cli-input-json file://task-definition.json

Step 4: Run a Service with Fargate

Create a Service:

   aws ecs create-service \
     --cluster flask-cluster \
     --service-name flask-service \
     --task-definition flask-task \
     --desired-count 1 \
     --launch-type FARGATE \
     --network-configuration "awsvpcConfiguration={subnets=[<your-subnet-id>],securityGroups=[<your-security-group-id>],assignPublicIp=ENABLED}"

Verify the Service:

   aws ecs list-services --cluster flask-cluster

Step 5: Test the Application

Retrieve the public IP of your running task:

List Tasks:

   aws ecs list-tasks --cluster flask-cluster

Describe the Task:

   aws ecs describe-tasks --cluster flask-cluster --tasks <task-id>

Access the Application: Open the public IP in your browser on port 5000. You should see your Flask app running.

Step 6: Monitor and Scale

Enable CloudWatch Logs: Add the following to your task-definition.json under containerDefinitions:

"logConfiguration": {
  "logDriver": "awslogs",
  "options": {
    "awslogs-group": "/ecs/flask-service",
    "awslogs-region": "<your-region>",
    "awslogs-stream-prefix": "ecs"
  }
}

Update the task definition and re-deploy the service to enable logging.

Scale the Service:

   aws ecs update-service --cluster flask-cluster --service flask-service --desired-count 3

Conclusion

In this walkthrough, we’ve deployed a containerized Flask application to AWS ECS using Fargate. By leveraging AWS’s fully managed services, we’ve minimized the operational overhead and focused entirely on the application. As you grow, explore features like auto-scaling, service discovery, and integration with CI/CD pipelines to optimize your deployments further.

Feel free to share your thoughts, or let me know if you encounter any challenges while implementing this workflow!

Guides To Python Web App on AWS Lightsail

ARAFAT O. OLAYIWOLA — Tue, 22 Jul 2025 15:57:44 +0000

Deploying a Django app on AWS Lightsail is a cost-effective and straightforward way to get your application online. In this guide, we'll walk through the process step-by-step, with examples to help you follow along.

Prerequisites

AWS Account: You need an AWS account to use Lightsail.
Django Application: Have a Django app ready to deploy.
Basic Knowledge of Django and the command line: Familiarity with Django project structure and basic command line usage will be helpful.

Step 1: Create an AWS Lightsail Instance

Log in to AWS Lightsail
- Go to the AWS Lightsail console.
- Sign in with your AWS account.

Create an Instance
- Click Create instance.
- Choose your instance location (e.g., a region close to your users).
- Under Select a blueprint, choose OS Only and then Ubuntu 20.04 LTS.
- Choose your instance plan based on your resource needs and budget.
- Give your instance a unique name.
- Click Create instance.

Step 2: Configure the Instance

Connect to Your Instance
- In the Lightsail console, click on the instance you just created.
- Click Connect using SSH to open a browser-based SSH terminal.
Update the Package Manager

   sudo apt-get update
   sudo apt-get upgrade

Install Python and Pip

   sudo apt-get install python3 python3-pip

Install Virtualenv

   sudo pip3 install virtualenv

Step 3: Deploy Your Django Application

Clone Your Django Project
- If your project is in a Git repository, clone it to your Lightsail instance:
```
 git clone https://github.com/yourusername/your-django-app.git
 cd your-django-app
```
Set Up a Virtual Environment

   virtualenv venv
   source venv/bin/activate

Install Dependencies

   pip install -r requirements.txt

Configure Your Django Settings
- Update settings.py to configure your database, static files, and allowed hosts. Ensure ALLOWED_HOSTS includes your Lightsail instance's IP address or domain name.
- Example:
```
 ALLOWED_HOSTS = ['your_instance_ip_or_domain']
```
Apply Migrations and Collect Static Files

   python manage.py migrate
   python manage.py collectstatic

Step 4: Set Up a Web Server and WSGI

Install Gunicorn

   pip install gunicorn

Test Gunicorn

   gunicorn --bind 0.0.0.0:8000 your_project_name.wsgi

Install and Configure Nginx

   sudo apt-get install nginx

Create an Nginx configuration file:

 sudo nano /etc/nginx/sites-available/your_project_name

Add the following configuration:

 server {
     listen 80;
     server_name your_instance_ip_or_domain;

     location / {
         proxy_pass http://127.0.0.1:8000;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
     }

     location /static/ {
         alias /path/to/your/static/files;
     }

     location /media/ {
         alias /path/to/your/media/files;
     }
 }

Enable the configuration:

 sudo ln -s /etc/nginx/sites-available/your_project_name /etc/nginx/sites-enabled
 sudo nginx -t
 sudo systemctl restart nginx

Step 5: Set Up a Systemd Service for Gunicorn

Create a Systemd Service File

   sudo nano /etc/systemd/system/gunicorn.service

Add the Following Configuration

   [Unit]
   Description=gunicorn daemon
   After=network.target

   [Service]
   User=your_username
   Group=www-data
   WorkingDirectory=/path/to/your/project
   ExecStart=/path/to/your/venv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/path/to/your/project.sock your_project_name.wsgi:application

   [Install]
   WantedBy=multi-user.target

Start and Enable the Service

   sudo systemctl start gunicorn
   sudo systemctl enable gunicorn

Step 6: Finalize Deployment

Open Ports in Lightsail
- In the Lightsail console, go to the Networking tab of your instance.
- Add a custom TCP port 80 for HTTP.
Access Your Application
- Visit your instance's IP address or domain in a web browser. You should see your Django application running.

Conclusion

You've successfully deployed a Django application on AWS Lightsail. This setup includes a secure and scalable environment using Nginx and Gunicorn to serve your app. For further enhancements, consider setting up SSL with Let's Encrypt and automating your deployments with CI/CD tools.

About the Author

Arafat is a third-year member of AWS Community Builder. He is passionate about software engineering and cloud computing by sharing knowledge with the community. The AWS Community Builders program provides me with the opportunity to connect with other cloud enthusiasts and stay updated with the latest AWS services and features.

Mastering AWS Container Orchestration: Lessons from a Third-Year AWS Community Builder

ARAFAT O. OLAYIWOLA — Thu, 23 Jan 2025 11:33:49 +0000

Mastering AWS Container Orchestration: Lessons from a Third-Year AWS Community Builder

As a third-year AWS Community Builder on the Containers team, I’ve had the privilege of exploring, implementing, and sharing insights about containerization and its orchestration in the cloud. Over the years, I’ve seen AWS continue to innovate and simplify the management of containerized workloads. Whether you’re just starting with containers or are already orchestrating large-scale applications, this guide highlights lessons learned, best practices, and emerging trends in AWS container services.

Why Containers? The Foundation of Modern Applications

Containers have transformed how we build, deploy, and scale applications. By packaging code, dependencies, and runtime into a single unit, containers:

Ensure consistency across development, testing, and production environments.
Enable micro-services architectures, making applications modular and scalable.
Reduce overhead compared to traditional virtual machines.

AWS offers a rich ecosystem for running containers, including Amazon Elastic Container Service (ECS), Amazon Elastic Kubernetes Service (EKS), and AWS Fargate for serverless container execution. Let’s dive into these services and how to leverage them effectively.

Getting Started: ECS vs. EKS vs. Fargate

Amazon ECS

Amazon ECS is a fully managed container orchestration service. It’s ideal for teams that want simplicity without diving into Kubernetes complexity. Key features include:

Tight integration with other AWS services like CloudWatch, IAM, and Load Balancers.
Support for both EC2 and Fargate launch types.
Task Definitions to define how containers should run.

Use Case: A simple microservices application with predictable scaling needs.

Amazon EKS

Amazon EKS provides a fully managed Kubernetes service. It’s a go-to for organizations with existing Kubernetes expertise or multi-cloud strategies. Key benefits include:

Full compatibility with upstream Kubernetes.
Access to Kubernetes tools like Helm, kubectl, and the Kubernetes API.
Seamless scaling with Karpenter or Cluster Autoscaler.

Use Case: Complex workloads requiring advanced Kubernetes features like custom controllers and operators.

AWS Fargate

AWS Fargate abstracts the underlying infrastructure, letting you focus entirely on containers. It works with both ECS and EKS, eliminating the need to manage EC2 instances. Highlights include:

Pay-as-you-go pricing based on vCPU and memory.
Automatic scaling and infrastructure management.
Enhanced security with task isolation.

Use Case: Workloads with sporadic usage patterns or serverless architecture requirements.

Advanced Strategies: Best Practices for Containers on AWS

1. Secure Your Containers

Security is paramount in any cloud architecture. Follow these practices:

Use AWS Secrets Manager to manage sensitive data like API keys and credentials.
Enable IAM roles for tasks to ensure least privilege access.
Regularly scan container images for vulnerabilities using tools like Amazon Inspector.

2. Optimize Cost and Performance

Cost optimization doesn’t mean compromising performance. Consider these tips:

Use Spot Instances with ECS or EKS for cost savings on compute resources.
Right-size containers using CloudWatch Container Insights to monitor resource utilization.
Consolidate smaller containers into fewer tasks when using ECS to reduce overhead.

3. Leverage Observability Tools

Gain full visibility into your containerized workloads by integrating observability tools:

Use AWS Distro for OpenTelemetry to collect metrics and traces.
Enable Container Insights for detailed monitoring and troubleshooting.
Integrate with third-party tools like Datadog or Prometheus for advanced analytics.

4. Automate with CI/CD

Streamline deployments with CI/CD pipelines:

Use AWS CodePipeline and CodeBuild for automating builds and deployments.
Integrate container registries like Amazon Elastic Container Registry (ECR).
Implement blue/green deployments with ECS Deployment Controller or Kubernetes operators.

Emerging Trends: What’s Next for Containers on AWS?

1. Serverless Kubernetes with EKS on Fargate

Combining the power of Kubernetes with serverless execution, EKS on Fargate eliminates the need to manage worker nodes. This trend is gaining traction for its simplicity and scalability.

2. Edge Containers with AWS Wavelength

Run containers closer to your users with AWS Wavelength, ideal for low-latency applications like IoT, gaming, and AR/VR.

3. Service Mesh Adoption

Tools like AWS App Mesh enable fine-grained traffic control, observability, and security for containerized microservices.

4. Sustainability in Containers

Efforts to optimize container workloads for sustainability are growing. AWS’s focus on renewable energy and tools to monitor carbon emissions can help teams align with green initiatives.

Lessons from the Field: Real-World Examples

Example 1: Scaling an E-commerce Platform

An e-commerce company leveraged ECS with Fargate for seasonal scalability. By using Application Auto Scaling, they seamlessly handled Black Friday traffic spikes while optimizing costs with Spot Instances.

Example 2: Migrating a Monolith to Microservices

A fintech startup transitioned from a monolithic application to a microservices architecture using EKS. With service mesh integration via App Mesh, they achieved observability and better fault isolation.

Final Thoughts: Build, Share, and Grow

Being an AWS Community Builder has underscored the importance of community and shared knowledge. Containers are an evolving technology, and AWS continues to lead in providing scalable, secure, and cost-effective solutions. By sharing your journey, challenges, and successes, you contribute to the broader community’s growth.

Whether you’re deploying your first container or managing thousands daily, AWS container services offer the tools and flexibility to build resilient, modern applications. Here’s to another year of innovation and collaboration within the AWS ecosystem!

If you’ve found this article helpful or have your own containerization experiences to share, drop a comment below or connect with me on X. Let’s keep the conversation going!

Building Bridges between Code and Community: Developer Relations

ARAFAT O. OLAYIWOLA — Tue, 16 Jan 2024 13:09:55 +0000

What is Developer Relation, DevRel?

According to the MoonGift Inc., DevRel is the marketing technique used to ensure that one's company, products, and developers establish a good, continuous relationship with external developers through mutual communication.

Furthermore, developer relations, also referred to as developer advocacy, play a vital role in product-oriented technology companies by bridging the gap between the community of developers who adopt their products and the products themselves that are being launched into the market. Developer relations professionals concentrate on fostering a mutually beneficial relationship between organizations and developer communities, facilitating strategic discussions on how to create compelling projects using the company's technologies.

The importance of Developer Advocacy

The unfortunate reality is that "not every company requires a Developer Relations (DevRel) team." Wondering why? Well, product-oriented industries often find it easier to advocate for their products in the market, leading to increased adoption and revenue in certain cases, as well as bolstering the organization's overall presence within the ecosystem.

Nevertheless, organizations that do have a DevRel team tend to reap several significant benefits, including:

a. Cultivating brand loyalty
b. Encouraging extensive community adoption and engagement
c. Attracting top talent
d. Generating interest from investors and more

**How to get started with Developer Relations Career

Experienced technical professionals with strong teaching, public speaking, and writing abilities often find it natural to transition into the field of developer advocacy. However, it is important to note that individuals without a technical background can also explore this area, as long as they are willing to invest time and effort into developing the necessary skills to become a successful developer relations professional.

Getting started with developer relations requires the following skills to be acquired:

Build your technical skills, like picking up any programming language and its framework and using it to develop applications in any domain of interest.
Learn how to write technical articles by communicating what you build to the community.
Attend and apply to speak at developer conferences, which help develop content creation and public speaking.
Apply to free and/or paid mentorship cohorts like DXMentorship, where you learn several other cogent skills useful for your career
Build your portfolio and resume - then start applying to internships and early career roles for more experience.
Continuous learning and learning !!!

*Opportunities in the DevRel Space
*

As a professional in the field of developer relations engineering, you have the privilege of enjoying several additional perks that may not be available to all your colleagues. These benefits are often essential for your company, as they contribute to revenue growth and enhance public recognition within the developer community. Here are some examples of these advantages:

Engaging with a diverse range of developers worldwide: In your role, you have the opportunity to interact with developers from various backgrounds and cultures. This exposure allows you to broaden your perspective, learn from different experiences, and build a global network of professional connections.

Complimentary attendance at conferences: Attending conferences is an integral part of your job, and your company recognizes its value. You have the privilege of attending these events at no cost, enabling you to stay up-to-date with the latest industry trends, connect with thought leaders, and share knowledge with fellow professionals.

Developing public speaking expertise: As a developer relations engineer, you regularly engage in public speaking engagements. Whether it's delivering presentations, leading workshops, or participating in panel discussions, you gain valuable experience in effectively communicating technical concepts to diverse audiences. This enhances your public speaking skills and boosts your professional profile.

Establishing yourself as a go-to expert within the company: Your role as a developer relations engineer positions you as a trusted authority within your organization. Colleagues and teams often rely on your expertise, insights, and guidance when it comes to understanding the needs and preferences of developers. This recognition can elevate your professional standing and contribute to your career growth.

Collaboration with executives at a strategic level: Given the strategic importance of developer relations, you have the opportunity to collaborate with executives at the staff level. This involvement allows you to provide valuable input on product development, marketing strategies, and overall business objectives. Working closely with senior leaders offers you visibility within the organization and allows you to contribute to important decision-making processes.

Thank you for reading, and do get started at DXMentorship.