DEV Community: Victor Okonkwo

Multi-AZ Architecture for High Availability and Fault Tolerance

Victor Okonkwo — Fri, 14 Mar 2025 12:42:58 +0000

This is an overview and step-by-step guide on how to set up a Multi-AZ (Availability Zone) architecture, designed for high availability and fault tolerance.

Click to view:
Multi-AZ Architecture for High Availability and Fault Tolerance

This architecture is designed to ensure high availability and fault tolerance for your application. It uses multiple Availability Zones (AZs) to make sure your services remain online, even if one zone experiences an outage.

Key Components:

VPC (Virtual Private Cloud):
- The VPC is a private network where all your resources live. It helps keep your infrastructure secure.
Public and Private Subnets:
- Public subnets host the Load Balancer, which handles incoming traffic from users.
- Private subnets hold your EC2 instances (servers) and RDS (database). These are not directly accessible from the internet, keeping them secure.
Load Balancer:
- The Load Balancer sits in the public subnets and evenly distributes user traffic to the EC2 instances in different AZs, preventing overload on any single server.
EC2 Instances:
- These are your web servers running in private subnets across multiple AZs. They host your application. The Auto Scaling group ensures that more instances are added or removed based on traffic.
RDS (Relational Database Service):
- RDS is your database, placed in private subnets for security. It’s set up in multiple AZs, meaning if one AZ fails, your database will still be available.
Auto Scaling:
- Automatically adjusts the number of EC2 instances based on traffic. This ensures that your application can handle sudden traffic spikes.
Internet Gateway:
- This allows resources in the public subnets (like the Load Balancer) to communicate with the internet.

This setup ensures that your application is reliable, secure, and can handle changes in traffic without downtime. If one part fails, another takes over, maintaining seamless operation.

Deploying a Custom Web Application with Docker & Docker Compose on AWS EC2

Victor Okonkwo — Mon, 03 Mar 2025 16:16:16 +0000

Prerequisites

An AWS Account with an active EC2 instance (Ubuntu 22.04 recommended)
A security group that allows inbound traffic on ports 22 (SSH), 8080, 8081, 8082 (HTTP)
A Docker Hub Account (Sign up at Docker Hub)
An SSH key to connect to your EC2 instance

Step 1: Set Up an EC2 Instance & Install Docker

Launch an EC2 instance (Ubuntu 22.04 recommended).
Connect to the instance via SSH:

   ssh -i your-key.pem ubuntu@your-ec2-public-ip

Update the system:

   sudo apt update && sudo apt upgrade -y

Install necessary dependencies:

   sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

Add Docker’s official GPG key:

   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Add Docker’s repository:

   echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker:

   sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io

Verify Docker installation:

   docker --version

Enable Docker to run without sudo (optional):

   sudo usermod -aG docker $USER
   newgrp docker

Note: If you enable this, log out and log back in for changes to take effect.

Step 2: Create a Web Application

Create a project directory:

   mkdir docker-project && cd docker-project

Create a folder for web files:

   mkdir web

Create an index.html file:

   nano web/index.html

Add the following content:

   <html>
   <head><title>My Docker App</title></head>
   <body><h1>Hello from Docker!</h1></body>
   </html>

Step 3: Create a Dockerfile

Create the Dockerfile:

   nano Dockerfile

Add the following:

   FROM nginx:latest
   COPY web /usr/share/nginx/html
   EXPOSE 80
   CMD ["nginx", "-g", "daemon off;"]

Build the Docker image:

   docker build -t my-web-app .

Run the container:

   docker run -d -p 8080:80 my-web-app

Test in browser: Visit http://your-ec2-public-ip:8080 You should see: "Hello from Docker!"

Step 4: Install Docker Compose

Download the latest Docker Compose binary:

   sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Apply execute permissions:

   sudo chmod +x /usr/local/bin/docker-compose

Verify installation:

   docker-compose --version

Step 5: Create a Docker Compose File

Create docker-compose.yml:

   nano docker-compose.yml

Add the following content:

   version: '3.8'

   services:
     web:
       build: .
       ports:
         - "8081:80"
       depends_on:
         - db

     db:
       image: mysql:latest
       restart: always
       environment:
         MYSQL_ROOT_PASSWORD: rootpassword
         MYSQL_DATABASE: testdb
         MYSQL_USER: user
         MYSQL_PASSWORD: password
       ports:
         - "3307:3306"

Run Docker Compose:

   docker-compose up -d

Verify running containers:

   docker ps

Step 6: Push the Image to Docker Hub

Log in to Docker Hub:

   docker login

Tag the image:

   docker tag my-web-app your-dockerhub-username/my-web-app:latest

Push the image:

   docker push your-dockerhub-username/my-web-app:latest

Step 7: Deploy on a New EC2 Instance

Launch a new Ubuntu EC2 instance.
SSH into the new instance:

   ssh -i your-key.pem ubuntu@new-ec2-public-ip

Install Docker:

   sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io

Log in to Docker Hub:

   docker login

Pull the image:

   docker pull your-dockerhub-username/my-web-app:latest

Run the container:

   docker run -d -p 8082:80 your-dockerhub-username/my-web-app:latest

Test in browser: Visit http://new-ec2-public-ip:8082

Deliverables

Dockerfile
docker-compose.yml
Screenshot of the web app running inside the container

This guide ensures a complete hands-on learning experience, covering Docker installation, building images, running containers, Docker Compose, pushing to Docker Hub, and deploying on a new server.

Setting Up a GitLab Server (Community Edition) and a GitLab Runner Using Docker Compose

Victor Okonkwo — Thu, 20 Feb 2025 14:56:26 +0000

Author: Victor Okonkwo

Overview

Set up a Docker-based GitLab and a GitLab Runner using Docker Compose to create a CI/CD environment. Services will be defined in the docker-compose.yml file, configuring storage, exposing GitLab on a local port, and registering the GitLab Runner to execute CI/CD pipelines. Verify the setup by running a test pipeline with a sample project.

Prerequisites

A Linux Ubuntu server with 4GB RAM and 10GB of free disk space for GitLab data and logs.
Docker and Docker Compose installed and running on your system.

Install Docker

Update package index:
```
sudo apt-get update
```

Install required packages:

sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

Add Docker's official GPG key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo tee /etc/apt/trusted.gpg.d/docker.gpg > /dev/null

Set up Docker repository:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Install Docker:

sudo apt-get update
sudo apt-get install -y docker-ce

Install Docker Compose

Download Docker Compose binary:

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Apply executable permissions:

sudo chmod +x /usr/local/bin/docker-compose

Verify installation:
```
docker-compose --version
```

Create the `docker-compose.yml` File

Create a directory and navigate into it:

mkdir gitlab-docker-setup
cd gitlab-docker-setup

Create a docker-compose.yml file with the following configuration:

version: '3.8'

services:
  gitlab-server:
    image: 'gitlab/gitlab-ce:latest'
    container_name: gitlab-server
    hostname: 'gitlab.example.com'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://<your-ec2-public-ip>:8088'  # Put the IP of your server
        gitlab_rails['initial_root_password'] = "my_secure_password"  # Set your initial root password here
    ports:
      - '8088:8088'  # Expose GitLab on port 8088
    volumes:
      - ./config:/etc/gitlab  # Persist GitLab configuration
      - ./logs:/var/log/gitlab  # Persist GitLab logs
      - ./data:/var/opt/gitlab  # Persist GitLab data
    restart: always

  gitlab-runner:
    image: 'gitlab/gitlab-runner:latest'
    container_name: gitlab-runner
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./runner/config:/etc/gitlab-runner
    restart: always

Start the Services

Run the following command to start both the GitLab server and the GitLab Runner:

docker-compose up -d

Ensure that your server has port 8088 open. The GitLab UI should be available at http://<your-EC2-public-IP>:8088. Initially, you might get a 502 error, but this should resolve as the services fully initialize.

Troubleshooting Steps

If GitLab is not displaying on your browser:

Verify Docker Containers:
```
docker ps
```
Check Docker Logs for GitLab:
```
docker logs gitlab-server
```

Confirm Port 8088 is Open:

aws ec2 describe-security-groups --group-ids <your-security-group-id> --query "SecurityGroups[*].IpPermissions"

Check for Firewalls:
```
sudo ufw status
```

Restart Docker Compose:

docker-compose down
docker-compose up -d

Configure the GitLab Runner

Access the GitLab UI:
```
http://<your-EC2-public-IP>:8088
```
Log in using root as the username and the password set in the docker-compose.yml file.
Create a new project in GitLab.
Go to Admin > CI/CD > Runners, and click on New instance runner to obtain the registration token.(tag the Runner; docker)

docker exec -it gitlab-runner gitlab-runner register

Follow the prompts:
- URL: http://gitlab-server:8088
- Token: Enter the token obtained from the GitLab UI.
- Description: docker
- Executor: docker

Create a `.gitlab-ci.yml` File

Create a .gitlab-ci.yml file in your project repository to define a simple CI pipeline:

stages:
  - test

test_node_version:
  stage: test
  image: alpine
  script:
    - apk add --no-cache nodejs  # Install Node.js in Alpine
    - node -v                    # Check Node.js version
  tags:
    - docker

Commit and push this change to trigger the pipeline:

git add .
git commit -m "Add CI pipeline"
git push origin main

And that's it!
Go back to your project page and watch it run.

You now have a fully functional GitLab server and GitLab Runner set up using Docker Compose.

Mastering Automation: An Introduction to Server Setup Scripting

Victor Okonkwo — Thu, 06 Feb 2025 21:13:53 +0000

Overview

In this guide, we’ll explore how to automate server provisioning using a simple Bash script. Automating server setups helps streamline the configuration of cloud instances, saving time and reducing the risk of manual errors. This script installs and configures essential tools such as the Apache web server, Docker for container management, and Git for version control.

Script Purpose

The script automates the following tasks:

Updating the server: Ensures all installed packages are up to date.
Installing Apache: Deploys a web server to handle HTTP requests.
Installing Docker: Sets up Docker for containerized applications.
Installing Git: Installs Git to manage code repositories.

This script is perfect for cloud engineers, DevOps professionals, or anyone looking to demonstrate proficiency in automating infrastructure setups.

The Script

#!/bin/bash

# Ensure the script is run as root
if [ "$EUID" -ne 0 ]; then
  echo "Please run as root"
  exit
fi

# Update server
echo "Updating server..."
apt update && apt upgrade -y

# Install Apache
echo "Installing Apache web server..."
apt install apache2 -y

# Install Docker
echo "Installing Docker..."
apt install docker.io -y
systemctl start docker
systemctl enable docker

# Install Git
echo "Installing Git..."
apt install git -y

# Output message
echo "Server setup complete. Apache, Docker, and Git are installed."

Explanation of Each Section

Shebang (Interpreter Directive):

   #!/bin/bash

This specifies that the script should be executed in the Bash shell. It tells the system to use /bin/bash as the interpreter for the script.

Ensuring Root Privileges:

   if [ "$EUID" -ne 0 ]; then
     echo "Please run as root"
     exit
   fi

This block checks if the script is being run as the root user. Installing system packages requires elevated permissions, so the script exits with an error message if the user is not root.

Updating the Server:

   apt update && apt upgrade -y

This command refreshes the package list (apt update) and upgrades installed packages (apt upgrade -y). The -y flag answers "yes" to any prompts, allowing the update to run without user interaction.

Installing Apache Web Server:

   apt install apache2 -y

This installs the Apache web server. Once installed, Apache will be able to handle HTTP requests on the server. The -y flag automatically accepts the installation.

Installing Docker:

   apt install docker.io -y
   systemctl start docker
   systemctl enable docker

These commands install Docker from the package repository and ensure Docker starts immediately (systemctl start docker) and after every server reboot (systemctl enable docker).

Installing Git:

   apt install git -y

This installs Git, a popular tool for version control, allowing you to manage code changes and collaborate with others.

Final Confirmation Message:

   echo "Server setup complete. Apache, Docker, and Git are installed."

A friendly message to inform the user that the setup has completed successfully.

How to Run the Script

Follow these steps to execute the script and automate your server setup:

1. Save the Script

Create a new file named setup_server.sh and copy the above script into the file.

2. Make the Script Executable

Before you can run the script, you need to give it executable permissions. Run the following command:

chmod +x setup_server.sh

3. Run the Script

To execute the script, use the following command with sudo (to ensure root privileges):

sudo ./setup_server.sh

4. Observe the Output

As the script runs, it will display messages at each step—updating the server, installing Apache, Docker, and Git—and will conclude with:

Server setup complete. Apache, Docker, and Git are installed.

Why Automate Server Setup?

Automating server setups improves efficiency, consistency, and security by eliminating human error and ensuring that every server is configured exactly the same way. With this script, anyone can spin up a new cloud server and have it ready with essential services in a matter of minutes.

Conclusion

This script demonstrates the power of automation in managing cloud infrastructure. By following this guide, you’ll master the basics of automating server provisioning, a crucial skill for DevOps and Cloud engineers.

Guide: Building and Deploying a FastAPI App for Number Classification

Victor Okonkwo — Wed, 05 Feb 2025 13:23:37 +0000

This guide walks through the steps to build a simple FastAPI application that classifies a number based on various mathematical properties (e.g., prime, perfect, Armstrong) and provides a fun fact from an external API. The application is then deployed and kept running persistently on an Ubuntu EC2 instance.

1. Setting Up the FastAPI App

FastAPI is a modern, fast (high-performance) web framework for building APIs with Python. It is built on top of Starlette for the web parts and Pydantic for data validation.

Steps to Build the App:

Create a Virtual Environment: Use venv to isolate project dependencies.

   python3 -m venv venv
   source venv/bin/activate

Install Dependencies: Install FastAPI, Uvicorn, and any other required libraries (requests for fetching fun facts).

   pip install fastapi uvicorn requests

Create Your FastAPI Application:
Create an app.py file where you define the endpoints and the number classification logic (prime check, perfect number check, Armstrong check, etc.). Use the Numbers API to fetch fun facts about the number.
Run the Application:
Use Uvicorn to run your app locally.

   uvicorn app:app --host 0.0.0.0 --port 8000

Visit http://localhost:8000 to access the app and http://localhost:8000/docs to view the automatic interactive Swagger API documentation.

2. Configuring CORS for Web Access

If your app will be accessed from different origins (like a frontend app), Cross-Origin Resource Sharing (CORS) needs to be configured to avoid restrictions.

Add the following middleware to your FastAPI app:

from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Allows all origins
    allow_credentials=True,
    allow_methods=["*"],  # Allows all methods
    allow_headers=["*"],  # Allows all headers
)

3. Handling Asynchronous Requests

FastAPI supports asynchronous programming, which helps in optimizing the performance of I/O-bound tasks, such as fetching data from an external API.

Use async and await to fetch fun facts asynchronously from the Numbers API:

async def get_fun_fact(n: int) -> str:
    try:
        response = requests.get(f"http://numbersapi.com/{n}/math")
        return response.text
    except:
        return f"{n} is a number"

4. Running the App in the Background on Ubuntu EC2

Once the app is running locally, you’ll want to keep it running persistently on a cloud server. Using Ubuntu EC2, you can ensure the app keeps running even after you disconnect by using tools like nohup or systemd.

Using `nohup`:

nohup uvicorn app:app --host 0.0.0.0 --port 8000 &

This command runs the FastAPI app in the background and saves logs to nohup.out. You can monitor logs by running:

tail -f nohup.out

Alternatively, Using systemd:

For more advanced management, you can create a systemd service to manage the app as a background service, ensuring it starts on boot and restarts on failure.

5. Testing the API

With your app running, you can test the endpoints using tools like Postman, cURL, or directly from the browser.

Example cURL Request:

curl -X GET "http://<your-ec2-ip>:8000/api/classify-number?number=42"

6. Documenting the API with Swagger

FastAPI automatically generates Swagger UI documentation at http://localhost:8000/docs. This documentation lets users interact with your API directly, making it easier for others to understand and use your endpoints.

7. Best Practices for Deployment

Running in the Background: Use tools like nohup or systemd to keep your app running persistently.
Monitoring Logs: Use tail or other log monitoring tools to ensure the app is functioning correctly and to catch any errors.
Scaling: Consider scaling your app with tools like Docker and Kubernetes for larger projects that require high availability.

Conclusion

By following these steps, you can build and deploy a FastAPI app that classifies numbers and provides fun facts, while also learning key concepts like asynchronous programming, API documentation, and cloud deployment. Keep the app running using nohup or systemd for persistence, and utilize CORS to allow your app to handle requests from different origins.

For detailed instructions and the full code, visit the GitHub Repository.

DevOps Stage 0 - NGINX Configuration

Victor Okonkwo — Thu, 30 Jan 2025 10:58:16 +0000

Task Overview:

This task involved setting up and configuring NGINX on a fresh Ubuntu server, creating a custom HTML page, and ensuring NGINX served the page correctly. It demonstrated my ability to work with basic web server configurations.

Step-by-Step Approach:

Set Up the Environment:
- I launched a fresh Ubuntu server and ensured it was up-to-date using:
```
 sudo apt update && sudo apt upgrade -y
```
NGINX Installation:
- I installed NGINX by running:
```
 sudo apt install nginx -y
```

After installation, I checked the service status to confirm it was running:
```
 sudo systemctl status nginx
```
The default NGINX welcome page confirmed a successful installation.

Custom HTML Page Configuration:
- I navigated to the NGINX web directory and created a custom HTML file:
```
 sudo nano /var/www/html/index.html
```

I added the following content, replacing placeholders with my name and Slack username:
```
 <h1>Welcome to DevOps Stage 0 - Victor Okonkwo/Teetoflame</h1>
```
After updating the file, I restarted NGINX to apply the changes:
```
 sudo systemctl restart nginx
```

I verified the configuration by accessing the server's IP address in a browser.

Challenges Faced:

I initially faced a permission issue when editing the index.html file. This was resolved by using sudo to gain root access.
Another challenge was ensuring that my custom HTML page overwrote the default NGINX page, which I confirmed by clearing the browser cache.

Learning and Professional Development:

This task helped me better understand the fundamentals of web server configuration using NGINX. It provided practical experience in deploying a web server, which is essential in DevOps for managing infrastructure and delivering applications.
By successfully configuring a web server, I improved my confidence in working with Linux and server management tools.

References:

This documentation summarizes the process and reflects my growing expertise in DevOps, particularly in web server configuration.

Deploying a Scalable Web Application on AWS

Victor Okonkwo — Thu, 23 Jan 2025 12:40:40 +0000

This detailed guide walks you through deploying a scalable web application using AWS services, including EC2, RDS, NGINX, Auto Scaling Groups, and Load Balancers. The example application will be a Flask app running on an EC2 instance, connected to an RDS database.

Part 1: Setting Up the EC2 Instance and Flask Application
Part 2: Configuring NGINX as a Reverse Proxy
Part 3: Integrating AWS RDS for Database
Part 4: Adding Auto-Scaling with Load Balancer
Part 5: Monitoring and Scaling with CloudWatch

Part 1: Setting Up the EC2 Instance and Flask Application

Steps:

Create an EC2 Instance:
- Use the AWS Management Console to launch a new EC2 instance.
- AMI: Choose Ubuntu.
- Instance Type: Select t2.micro (Free Tier eligible).
- Configure Security Groups: Allow SSH (port 22) and HTTP (port 80).

Connect to the Instance:
- Use VS Code to connect to the instance via SSH.
- Update and upgrade the instance:
```
 sudo apt update && sudo apt upgrade -y
```
Install Python and Set Up Virtual Environment:
- Install Python and pip:
```
 sudo apt install python3 python3-pip -y
```

Install virtual environment:
```
 sudo apt install python3-venv -y
```

Create and activate a virtual environment:

 python3 -m venv myenv
 source myenv/bin/activate

Install Flask and Dependencies:
- Install Flask, Gunicorn, and psycopg2-binary:
```
 pip install flask gunicorn psycopg2-binary
```

Verify the installations:
```
 pip list
```

Create the Flask Application:
- Create a file named application.py:
```
 nano application.py
```

Paste the following Flask code into application.py:

 from flask import Flask
 app = Flask(__name__)

 @app.route('/')
 def home():
     return "Hello, Flask on EC2!"

 if __name__ == "__main__":
     app.run(host='0.0.0.0', port=5000)

Ensure the file has the correct permissions:
```
 chmod 644 application.py
```

Run Flask with Gunicorn:

   gunicorn -w 3 -b 0.0.0.0:5000 application:app

Test the Application:
- Access the Flask application in your browser: http://your-ec2-public-ip:5000

Part 2: Configuring NGINX as a Reverse Proxy

Install NGINX:

   sudo apt install nginx -y

Configure NGINX:

Open the NGINX configuration file:

 sudo nano /etc/nginx/sites-available/flask-app

Add the following configuration:

 server {
     listen 80;
     server_name <your-ec2-public-ip>;

     location / {
         proxy_pass http://127.0.0.1:5000;
         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;
     }
 }

Enable the Configuration:

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

Test the Application on Port 80:
- Access your Flask application at: http://your-ec2-public-ip

Part 3: Integrating AWS RDS for Database

Create an RDS Instance:
- Use AWS RDS Free Tier to create a MySQL database.
- Set it to publicly accessible.

Install Database Client Libraries:
- Install pymysql for MySQL:
```
 pip install pymysql
```

Verify installation:
```
 pip show pymysql
```

Set Up the Database:

Connect to your RDS instance:

 mysql -h <RDS_ENDPOINT> -u <USERNAME> -p

Create a sample database and table:

 CREATE DATABASE flaskapp;
 USE flaskapp;

 CREATE TABLE messages (
     id INT AUTO_INCREMENT PRIMARY KEY,
     content VARCHAR(255) NOT NULL
 );

 INSERT INTO messages (content) VALUES ('Hello from RDS!');

Update Flask App to Use RDS:

Edit application.py to connect to RDS and fetch data:

 from flask import Flask
 import pymysql

 app = Flask(__name__)

 # RDS Configuration
 DB_HOST = "flask-app-db.xxxxxxx.us-east-1.rds.amazonaws.com"
 DB_USER = "admin"
 DB_PASSWORD = "yourpassword"
 DB_NAME = "flaskapp"

 def get_db_connection():
     return pymysql.connect(
         host=DB_HOST,
         user=DB_USER,
         password=DB_PASSWORD,
         database=DB_NAME,
         cursorclass=pymysql.cursors.DictCursor
     )

 @app.route("/")
 def home():
     connection = get_db_connection()
     try:
         with connection.cursor() as cursor:
             cursor.execute("SELECT content FROM messages")
             result = cursor.fetchall()
             messages = [row["content"] for row in result]
             return "<br>".join(messages)
     finally:
         connection.close()

 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=5000, debug=True)

Restart Flask Application:
- Restart the Flask app to apply the changes:
```
 python application.py
```
Test the Application:
- Access your Flask application at: http://your-ec2-public-ip

Part 4: Adding Auto-Scaling with Load Balancer

1. Create an Amazon Machine Image (AMI):

Log in to the AWS Management Console and go to EC2 Dashboard.
Select your running EC2 instance that has the Flask app configured.
In the Actions dropdown, under Image and templates, select Create image.
In the Create Image dialog, give your image a name (e.g., flask-app-ami), and optionally provide a description.
Click Create Image. AWS will begin creating the AMI. It might take a few minutes to complete.
Once the image is created, you’ll be able to launch new instances based on this AMI.

2. Set Up an Auto Scaling Group:

Log in to the AWS Management Console and go to the EC2 Dashboard.
Under Auto Scaling, select Auto Scaling Groups and click Create an Auto Scaling group.
Select your AMI:
- Choose Custom AMI and select the AMI you just created.
Choose an Instance Type:
- Choose an instance type like t2.micro for testing (or any suitable instance type).
Configure the Auto Scaling Group:
- Provide a name for the group (e.g., flask-app-ASG).
- Choose your desired VPC and Subnets.
- Set Scaling Policies to scale up at 70% CPU utilization and scale down at 40% CPU utilization.
Set up Load Balancer:
- You'll configure a Target Group later for the Elastic Load Balancer.
Review and Create the ASG:
- Review the settings and click Create Auto Scaling group.

3. Add an Elastic Load Balancer (ELB):

Log in to the AWS Management Console and go to EC2 Dashboard.
Select Load Balancers and click Create Load Balancer.
Select Application Load Balancer (ALB).
Provide a name (e.g., flask-app-ALB) and choose internet-facing.
Select your VPC and the appropriate availability zones (AZs).
Configure Listeners:
- By default, ALB listens on HTTP (port 80). You can modify this if needed.
Create a Target Group:
- Choose Instance as the target type.
- For health checks, select HTTP and path / (to check the homepage of your Flask app).
Register your instances with this target group.
Assign Load Balancer to Auto Scaling Group:
- When you create the Auto Scaling Group (ASG), assign this Load Balancer to the ASG so it can distribute traffic across the instances in the ASG.
Update Security Groups:
- Ensure that the security group for the load balancer allows inbound traffic on port 80.
- Ensure your EC2 instances' security group allows inbound traffic from the load balancer.

4. Update NGINX Configuration for Private IP:

Find the Private IP of the Instance:
- In your EC2 Dashboard, under Instances, find the instance and copy its private IP.

Update NGINX Configuration:

Update the NGINX config to bind to the private IP:

   server {
       listen 80;
       server_name <your-ec2-public-ip>;  # Replace with your EC2 public IP or domain name

       location / {
           proxy_pass http://127.0.0.1:5000;  # Ensure this matches your Flask app's port
           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;
       }
   }

Restart NGINX:
```
 sudo systemctl restart nginx
```

5. Test Load Balancing:

Simulate load using tools like ApacheBench:
```
 ab -n 1000 -c 10 http://<ALB-DNS-name>/
```
- -n 1000: Number of requests.
- -c 10: Number of concurrent requests.

Using Locust:

Install Locust:

   pip install locust

Create a locustfile.py:

   from locust import HttpUser, between, task

   class LoadTest(HttpUser):
       wait_time = between(1, 3)

       @task
       def home(self):
           self.client.get("/")

Run Locust:

   locust -f locustfile.py --host http://<ALB-DNS-name>

Access Locust's web UI (usually at http://localhost:8089) to start the load test.

Part 5: Monitoring and Scaling with CloudWatch

To ensure your application is running smoothly and efficiently, you'll set up monitoring for your EC2 instance, RDS database, and Load Balancer using AWS CloudWatch. Additionally, you'll configure alarms for critical metrics.

Step 1: Log EC2 Application Data

Install the CloudWatch Agent

Install CloudWatch Agent:

 sudo apt update
 sudo apt install -y amazon-cloudwatch-agent

Verify Installation:
```
 amazon-cloudwatch-agent-ctl -a status
```

Configure the CloudWatch Agent

Create a Configuration File:

 sudo nano /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json

Example Configuration:

 {
    "logs": {
        "logs_collected": {
            "files": {
                "collect_list": [
                    {
                        "file_path": "/var/log/nginx/access.log",
                        "log_group_name": "nginx-logs",
                        "log_stream_name": "{instance_id}/access.log"
                    },
                    {
                        "file_path": "/var/log/nginx/error.log",
                        "log_group_name": "nginx-logs",
                        "log_stream_name": "{instance_id}/error.log"
                    },
                    {
                        "file_path": "/home/ubuntu/flask-app.log",
                        "log_group_name": "flask-logs",
                        "log_stream_name": "{instance_id}/flask-app.log"
                    }
                ]
            }
        }
    }
 }

Replace /home/ubuntu/flask-app.log with the actual log file path for your Flask app.

Start the Agent

Start the CloudWatch Agent:

 sudo amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json -s

Verify Logs in CloudWatch:
- Go to the CloudWatch Console → Log Groups → Verify nginx-logs and flask-logs.

Step 2: Enable Alarms

EC2 Monitoring

Enable Detailed Monitoring:
- In the EC2 Console, select your instance → Actions → Monitor and troubleshoot → Manage detailed monitoring.
Set Up an Alarm for CPU Usage:
- Go to CloudWatch Console → Alarms → Create alarm.
- Select the CPUUtilization metric for your EC2 instance.
- Set the threshold (e.g., >70% for 5 minutes).
- Configure the action to send an email via SNS (Simple Notification Service).

Install Memory Monitoring:

Add memory usage metrics to the CloudWatch Agent configuration:

   sudo nano /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json

Add this block under the "metrics" section:

   {
      "metrics": {
          "append_dimensions": {
              "InstanceId": "${aws:InstanceId}"
          },
          "metrics_collected": {
              "mem": {
                  "measurement": [
                      "mem_used_percent"
                  ],
                  "metrics_collection_interval": 60
              }
          }
      }
   }

Restart the CloudWatch Agent:

   sudo systemctl restart amazon-cloudwatch-agent

RDS Monitoring

Enable Enhanced Monitoring for RDS:
- Go to the RDS Console, select your database.
- Modify the database instance and enable Enhanced Monitoring with a granularity of 1 minute.
- Metrics like CPUUtilization, ReadIOPS, and WriteIOPS will now be available in CloudWatch.
Create an Alarm for RDS:
- Go to CloudWatch Console → Alarms → Create alarm.
- Select an RDS metric (e.g., CPUUtilization).
- Set a threshold (e.g., >70% for 5 minutes) and configure an SNS action.

Load Balancer Monitoring

Enable ELB Metrics:
- In the Load Balancer Console, make sure CloudWatch Metrics are enabled for your ELB.
- Metrics like RequestCount and HTTPCode_Backend_5XX will appear in CloudWatch.
Create an Alarm for ELB:
- Go to CloudWatch Console → Alarms → Create alarm.
- Select an ELB metric (e.g., UnhealthyHostCount).
- Set a threshold (e.g., >1 unhealthy instance for 5 minutes) and configure an SNS action.

Step 3: Test Monitoring and Alarms

Simulate High CPU Usage

Use a stress testing tool like stress to simulate high CPU:

 sudo apt install -y stress
 stress --cpu 2 --timeout 300

Check CloudWatch for alerts.

Generate Logs

Access your Flask app and force some errors (e.g., incorrect database queries) to populate error logs in CloudWatch.

Recap

CloudWatch Logs: Capturing logs from NGINX and Flask.
EC2 Monitoring: Alarms for CPU and memory usage.
RDS Monitoring: Tracking database performance.
ELB Monitoring: Health checks and request distribution.

With these steps, you can ensure that your application is monitored for performance and reliability. AWS CloudWatch provides the tools to keep an eye on your infrastructure and respond proactively to any issues.

Part 6: Setting Environment Variables

Using environment variables to store sensitive data such as database credentials and application secrets helps in securely managing and accessing these values without hardcoding them into your application. This can also be achieved using AWS Systems Manager Parameter Store, but here we'll focus on environment variables.

Step 1: Set Environment Variables on Your EC2 Instance

Edit the .bashrc or .profile File:
- Open the .bashrc file using a text editor:
```
 sudo nano ~/.bashrc
```

Add your credentials as environment variables at the end of the file:

 export DB_HOST="database-1.c1u22o08cg4k.eu-north-1.rds.amazonaws.com"
 export DB_USER="admin"
 export DB_PASSWORD="SheepliFe6"
 export DB_NAME="database1"

Save the file and reload it:
```
 source ~/.bashrc
```

Verify Environment Variables:
- Run the following commands to confirm the variables are set:
```
 echo $DB_HOST
 echo $DB_USER
 echo $DB_PASSWORD
 echo $DB_NAME
```

Step 2: Update Your Flask App

Modify Your Flask App to Use Environment Variables:

Edit application.py to pull sensitive data from environment variables:

 import os
 from flask import Flask
 import pymysql

 app = Flask(__name__)

 # RDS Configuration from Environment Variables
 DB_HOST = os.getenv("DB_HOST")
 DB_USER = os.getenv("DB_USER")
 DB_PASSWORD = os.getenv("DB_PASSWORD")
 DB_NAME = os.getenv("DB_NAME")

 # Database Connection
 def get_db_connection():
     return pymysql.connect(
         host=DB_HOST,
         user=DB_USER,
         password=DB_PASSWORD,
         database=DB_NAME,
         cursorclass=pymysql.cursors.DictCursor
     )

 @app.route("/")
 def home():
     connection = get_db_connection()
     try:
         with connection.cursor() as cursor:
             cursor.execute("SELECT content FROM messages")
             result = cursor.fetchall()
             messages = [row["content"] for row in result]
             return "<br>".join(messages)
     finally:
         connection.close()

 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=5000)

Why Use These Approaches?

Environment Variables:

Simple and straightforward for small-scale apps.
Quick to set up during development.
Enhances security by avoiding hardcoding sensitive information in the application code.

Documentation: Pushing and Pulling a Docker Image to Docker Hub

Victor Okonkwo — Tue, 10 Dec 2024 13:07:37 +0000

This guide walks you through the steps to push a custom WordPress image to Docker Hub and verify it by pulling it back. It's designed to be beginner-friendly!

Step 1: Create a Docker Hub Account

Sign Up for Docker Hub:
- Go to the Docker Hub website.
- Click on Sign Up.
- Fill in the required details to create your account.

Step 2: Prepare Your Docker Image

Tag the Image: To push an image to Docker Hub, it needs to be tagged correctly with the format:

   [DockerHubUsername]/[RepositoryName]:[Tag]

Example:

   docker tag [IMAGE_ID] your-username/wordpress:latest

In my case, I tagged my WordPress image:

   docker tag 2f3572d5cd72 your-username/wordpress:latest

2f3572d5cd72 is the image ID of my WordPress container.
your-username/wordpress:latest is the name and tag for the image in my Docker Hub repository.

Step 3: Push the Image to Docker Hub

Login to Docker Hub: Before pushing an image, make sure you're logged in using:

   docker login

Push the Tagged Image: Use the docker push command to upload the image to Docker Hub:

   docker push your-username/wordpress:latest

The output showed Docker uploading layers of my image to the repository. If some layers were already present in the official WordPress image, Docker reused them.

Successful Push Confirmation: The output ended with:

   latest: digest: sha256:78a7f1bd075abad746e53aca7605976c2cf76796b1f868bc3adb17a98bbf0287 size: 5161

This confirmed that the image was successfully pushed.

Step 4: Verify the Image on Docker Hub

Check the Repository Online: I logged in to Docker Hub and navigated to my repository (your-username/wordpress). The image with the latest tag was listed there.

Step 5: Pull the Image to Verify

Pull the Image: To test that the image works, I pulled it from Docker Hub using:

   docker pull your-username/wordpress:latest

This downloaded the image from Docker Hub.
The successful pull confirmed that the image was stored correctly.

Tips & Notes

Login to Docker Hub: Before pushing an image, make sure you're logged in using:

  docker login

Repository Naming: The name must include your Docker Hub username (e.g., your-username/wordpress).

That's it! Your WordPress image is now available on Docker Hub and ready for deployment anywhere.

Installing Docker and Deploying WordPress with MySQL (with WSL2)

Victor Okonkwo — Mon, 09 Dec 2024 10:11:29 +0000

This guide provides detailed instructions on how to install Docker Desktop on a Windows system with WSL2 and deploy WordPress with a MySQL database using Docker containers.

Part 1: Installing Docker

Steps Followed:

Install Docker Desktop:
- Download Docker Desktop from the official Docker website.
- Follow the installation prompts to install Docker Desktop.
- Enable WSL 2 integration during the installation process to integrate Docker with the Ubuntu distribution on WSL (if used).

Verify Docker Installation:
- Open PowerShell and check the Docker version:
```
 docker --version
```

Test Docker functionality by running:
```
 docker run hello-world
```

Part 2: MySQL and WordPress Containers Deployment

Prerequisites:

Docker Desktop is up and running.

Run MySQL and WordPress Containers in a Single Command:
You can run both containers simultaneously using a single line in PowerShell:

docker run --name wp-mysql -e MYSQL_ROOT_PASSWORD=rootpass -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wpuser -e MYSQL_PASSWORD=wppass -v wp-mysql-data:/var/lib/mysql -p 3306:3306 -d mysql:5.7 && docker run --name wp-wordpress -e WORDPRESS_DB_HOST=wp-mysql:3306 -e WORDPRESS_DB_USER=wpuser -e WORDPRESS_DB_PASSWORD=wppass -e WORDPRESS_DB_NAME=wordpress -v wp-html:/var/www/html -p 8080:80 --link wp-mysql:mysql -d wordpress:latest

Explanation of Commands:

MySQL Container:

docker run --name wp-mysql \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wppass \
  -v wp-mysql-data:/var/lib/mysql \
  -p 3306:3306 \
  -d mysql:5.7

--name wp-mysql: Specifies the container name wp-mysql.
-e MYSQL_ROOT_PASSWORD=rootpass: Sets the MySQL root password.
-e MYSQL_DATABASE=wordpress: Creates the database wordpress.
-e MYSQL_USER=wpuser and -e MYSQL_PASSWORD=wppass: Creates a user wpuser with the password wppass.
-v wp-mysql-data:/var/lib/mysql: Creates a volume for MySQL data persistence.
-p 3306:3306: Maps MySQL's port 3306 to the host machine.
-d: Runs the container in detached mode.

WordPress Container:

docker run --name wp-wordpress \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wppass \
  -e WORDPRESS_DB_NAME=wordpress \
  -v wp-html:/var/www/html \
  -p 8080:80 \
  --link wp-mysql:mysql \
  -d wordpress:latest

--name wp-wordpress: Specifies the container name wp-wordpress.
-e WORDPRESS_DB_HOST=wp-mysql:3306: Points WordPress to the MySQL container (wp-mysql).
-e WORDPRESS_DB_USER, -e WORDPRESS_DB_PASSWORD, -e WORDPRESS_DB_NAME: Credentials for connecting WordPress to MySQL.
-v wp-html:/var/www/html: Creates a volume for WordPress files.
-p 8080:80: Maps port 80 inside the container to port 8080 on the host machine.
--link wp-mysql:mysql: Links the WordPress container to the MySQL container.

Accessing WordPress

Open your browser and go to:
http://localhost:8080
Follow the WordPress setup instructions to finish configuring your site.

Common Docker Commands for Management

Check Running Containers:

docker ps

Stop Containers:

docker stop wp-mysql wp-wordpress

Start Containers:

docker start wp-mysql wp-wordpress

Remove Containers:

docker rm -f wp-mysql wp-wordpress

Remove Volumes:

docker volume rm wp-mysql-data wp-html

This documentation summarizes the process of installing Docker and deploying WordPress and MySQL containers using WSL2 on Windows. With these visual aids and detailed explanations, it should be easier for users to follow along and successfully complete the setup.

Deploying Configurable and Clustered Web Servers Using Terraform

Victor Okonkwo — Mon, 09 Dec 2024 09:59:19 +0000

In this post, I’ll walk you through deploying a configurable web server and a clustered web server using Terraform. We'll explore the key differences between these two approaches and demonstrate how Terraform simplifies infrastructure as code deployment.

What is Terraform?

Terraform is an open-source infrastructure as code (IaC) tool that allows you to define and provision infrastructure using configuration files. By leveraging a declarative approach, Terraform enables you to manage and automate the provisioning of resources across multiple cloud providers, such as AWS, Azure, and Google Cloud.

For this tutorial, we will focus on AWS as our cloud provider, where we’ll deploy EC2 instances for both configurations. The key difference between the two is in their scalability and architecture. Let’s break it down into two parts:

Part 1: Deploying a Configurable Web Server

A configurable web server is an EC2 instance that you can configure with parameters like instance type, region, and key pair. This type of setup is great for simple, low-traffic applications or testing purposes.

Steps to Deploy a Configurable Web Server:

Set up the environment: Ensure that you have Terraform installed and your AWS credentials configured. You can use the AWS CLI for this:

   aws configure

Define the Terraform Configuration: Create a main.tf file that specifies the resources we need, such as:
- EC2 instance: A web server that will serve content.
- Security group: To allow HTTP traffic on port 80.

Here’s an example of what the main.tf file might look like:

   provider "aws" {
     region = "us-east-1"  # Set the AWS region
   }

   variable "instance_type" {
     default = "t3.micro"
   }

   variable "ami_id" {
     default = "ami-075449515af5df0d1"  # Ubuntu 20.04 AMI
   }

   variable "key_pair_name" {
     default = "bincom"
   }

   resource "aws_security_group" "allow_http" {
     name_prefix = "allow_http"
     ingress {
       from_port   = 80
       to_port     = 80
       protocol    = "tcp"
       cidr_blocks = ["0.0.0.0/0"]
     }
     egress {
       from_port   = 0
       to_port     = 0
       protocol    = "-1"
       cidr_blocks = ["0.0.0.0/0"]
     }
   }

   resource "aws_instance" "web" {
     ami           = var.ami_id
     instance_type = var.instance_type
     key_name      = var.key_pair_name
     security_groups = [aws_security_group.allow_http.name]

     tags = {
       Name = "ConfigurableWebServer"
     }
   }

   output "web_server_public_ip" {
     value = aws_instance.web.public_ip
   }

Run Terraform Commands:
- Initialize Terraform:
```
 terraform init
```

Plan the Deployment:
```
 terraform plan
```
Apply the Configuration:
```
 terraform apply
```

Terraform will provision the web server with the defined configurations, and after the deployment is complete, it will output the public IP of the EC2 instance, which you can use to access your web server.

Key Takeaways:

Customizable Parameters: You can easily change parameters like instance type, region, and AMI ID.
Single EC2 Instance: This configuration creates only one instance, suitable for low-traffic applications.

Part 2: Deploying a Clustered Web Server

A clustered web server setup involves multiple EC2 instances running behind a load balancer. This configuration is ideal for scaling applications and ensuring high availability. If one instance fails, the load balancer can route traffic to healthy instances in the cluster, making the setup more resilient.

Steps to Deploy a Clustered Web Server:

Extend the Terraform Configuration: To create a clustered web server, we will:
- Create an Auto Scaling Group (ASG) to manage multiple EC2 instances.
- Add an Elastic Load Balancer (ELB) to distribute incoming traffic across the instances in the cluster.

Here’s the updated main.tf configuration for the clustered setup:

   resource "aws_security_group" "allow_http" {
     name_prefix = "allow_http"
     ingress {
       from_port   = 80
       to_port     = 80
       protocol    = "tcp"
       cidr_blocks = ["0.0.0.0/0"]
     }
     egress {
       from_port   = 0
       to_port     = 0
       protocol    = "-1"
       cidr_blocks = ["0.0.0.0/0"]
     }
   }

   resource "aws_launch_configuration" "web" {
     image_id        = var.ami_id
     instance_type   = var.instance_type
     key_name        = var.key_pair_name
     security_groups = [aws_security_group.allow_http.id]

     user_data = <<-EOF
       #!/bin/bash
       sudo apt update
       sudo apt install -y apache2
       sudo systemctl start apache2
     EOF
   }

   resource "aws_autoscaling_group" "web" {
     desired_capacity     = 2
     max_size             = 3
     min_size             = 1
     launch_configuration = aws_launch_configuration.web.id
     vpc_zone_identifier  = [aws_subnet.main.id]
   }

   resource "aws_elb" "web" {
     name               = "web-load-balancer"
     availability_zones = ["us-east-1a", "us-east-1b"]

     listener {
       instance_port     = 80
       instance_protocol = "HTTP"
       lb_port           = 80
       lb_protocol       = "HTTP"
     }

     health_check {
       target              = "HTTP:80/"
       interval            = 30
       timeout             = 5
       healthy_threshold   = 2
       unhealthy_threshold = 2
     }
   }

   output "load_balancer_dns" {
     value = aws_elb.web.dns_name
   }

Run Terraform Commands:
- Initialize Terraform:
```
 terraform init
```

Plan the Deployment:
```
 terraform plan
```
Apply the Configuration:
```
 terraform apply
```

Once the Terraform plan is applied, you will have:

An Auto Scaling Group that will automatically manage the number of instances in the cluster based on traffic.
An Elastic Load Balancer that will distribute traffic across the instances in the Auto Scaling Group.

Key Takeaways:

Multiple Instances: The clustered web server configuration spins up multiple EC2 instances, ensuring high availability and fault tolerance.
Elastic Load Balancer (ELB): ELB distributes traffic across multiple EC2 instances, providing a balanced load.
Auto Scaling: The Auto Scaling Group dynamically adjusts the number of instances based on demand, which ensures scalability.

Conclusion

In this post, we learned how to deploy both a configurable web server and a clustered web server using Terraform. While the configurable web server is a great option for simple or low-traffic websites, the clustered web server provides higher availability and scalability, making it suitable for production-grade applications.

By leveraging Terraform’s Infrastructure as Code (IaC) capabilities, we can automate the deployment of web servers, making the process reproducible and easy to manage across multiple environments.

Happy Terraforming!

Installing Docker and Deploying WordPress with MySQL

Victor Okonkwo — Fri, 06 Dec 2024 13:24:08 +0000

Part 1: Installing Docker

Steps Followed:

Install Docker Desktop:
- Download Docker Desktop from the official Docker website.
- Follow the installation prompts to install Docker Desktop.
- Enable WSL 2 integration during the installation process to integrate Docker with the Ubuntu distribution on WSL (if used).

Verify Docker Installation:
- Open PowerShell and check the Docker version:
```
 docker --version
```

Test Docker functionality by running:
```
 docker run hello-world
```

Part 2: MySQL and WordPress Containers Deployment

Prerequisites:

MySQL already installed on your system.
Docker Desktop is up and running.

Run MySQL and WordPress Containers in a Single Command:
You can run both containers simultaneously using a single line in PowerShell:

docker run --name wp-mysql -e MYSQL_ROOT_PASSWORD=rootpass -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wpuser -e MYSQL_PASSWORD=wppass -v wp-mysql-data:/var/lib/mysql -p 3306:3306 -d mysql:5.7 && docker run --name wp-wordpress -e WORDPRESS_DB_HOST=wp-mysql:3306 -e WORDPRESS_DB_USER=wpuser -e WORDPRESS_DB_PASSWORD=wppass -e WORDPRESS_DB_NAME=wordpress -v wp-html:/var/www/html -p 8080:80 --link wp-mysql:mysql -d wordpress:latest

Explanation of Commands:

MySQL Container:

docker run --name wp-mysql \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wppass \
  -v wp-mysql-data:/var/lib/mysql \
  -p 3306:3306 \
  -d mysql:5.7

--name wp-mysql: Specifies the container name wp-mysql.
-e MYSQL_ROOT_PASSWORD=rootpass: Sets the MySQL root password.
-e MYSQL_DATABASE=wordpress: Creates the database wordpress.
-e MYSQL_USER=wpuser and -e MYSQL_PASSWORD=wppass: Creates a user wpuser with the password wppass.
-v wp-mysql-data:/var/lib/mysql: Creates a volume for MySQL data persistence.
-p 3306:3306: Maps MySQL's port 3306 to the host machine.
-d: Runs the container in detached mode.

WordPress Container:

docker run --name wp-wordpress \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wppass \
  -e WORDPRESS_DB_NAME=wordpress \
  -v wp-html:/var/www/html \
  -p 8080:80 \
  --link wp-mysql:mysql \
  -d wordpress:latest

--name wp-wordpress: Specifies the container name wp-wordpress.
-e WORDPRESS_DB_HOST=wp-mysql:3306: Points WordPress to the MySQL container (wp-mysql).
-e WORDPRESS_DB_USER, -e WORDPRESS_DB_PASSWORD, -e WORDPRESS_DB_NAME: Credentials for connecting WordPress to MySQL.
-v wp-html:/var/www/html: Creates a volume for WordPress files.
-p 8080:80: Maps port 80 inside the container to port 8080 on the host machine.
--link wp-mysql:mysql: Links the WordPress container to the MySQL container.

Part 3: Accessing WordPress

Open your browser and go to:

   http://localhost:8080

Follow the WordPress setup instructions to finish configuring your site.

Common Docker Commands for Management

Check Running Containers:

docker ps

Stop Containers:

docker stop wp-mysql wp-wordpress

Start Containers:

docker start wp-mysql wp-wordpress

Remove Containers:

docker rm -f wp-mysql wp-wordpress

Remove Volumes:

docker volume rm wp-mysql-data wp-html

This documentation summarizes the process of installing Docker and deploying WordPress and MySQL containers.

Step-by-Step Guide to Setting Up Terraform, AWS CLI, and VS Code

Victor Okonkwo — Thu, 05 Dec 2024 13:18:26 +0000

Introduction

Setting up your development environment is crucial for productivity and efficiency. In this guide, I’ll walk you through the process of installing and configuring Terraform, AWS CLI, and Visual Studio Code (VS Code). Whether you’re a beginner or looking for a refresher, this guide will help you get started quickly.

Prerequisites

Before we begin, ensure you have the following:

An AWS account
Basic knowledge of command line interface (CLI)
Internet connection

Step 1: Install Terraform

Terraform is an open-source tool for building, changing, and versioning infrastructure safely and efficiently.

Download Terraform:
- Go to the Terraform download page.
- Choose the version for your operating system (Windows, MacOS, Linux).
Install Terraform:
- On Windows: Extract the downloaded ZIP file and move the terraform.exe file to a directory included in your system's PATH.
- On MacOS/Linux: Extract the downloaded ZIP file, and move the terraform binary to /usr/local/bin.
Verify Installation:
Open your terminal or command prompt and run:

   terraform --version

If you see the Terraform version, you’ve successfully installed it.

Step 2: Install AWS CLI

AWS CLI enables you to interact with AWS services using commands in your terminal.

Download and Install AWS CLI:
- Follow the official instructions for your operating system.
Configure AWS CLI:
Open your terminal and run:

   aws configure

Enter your AWS Access Key ID, Secret Access Key, region, and output format (e.g., JSON).

Step 3: Install Visual Studio Code (VS Code)

VS Code is a powerful, lightweight code editor from Microsoft.

Download VS Code:
- Go to the VS Code download page.
- Choose the version for your operating system and follow the installation instructions.
Install Extensions:
- Open VS Code and go to the Extensions view by clicking the Extensions icon in the Activity Bar.
- Install the following extensions:
  - Terraform by HashiCorp
  - AWS Toolkit
  - Prettier - Code formatter (optional but recommended)

Tips and Challenges

Paths and Environment Variables: Ensure that the directories for terraform and aws are included in your system’s PATH.
AWS CLI Configuration: Double-check your AWS credentials and region to avoid issues during configuration.
VS Code Extensions: Explore additional extensions to enhance your productivity. The VS Code marketplace is filled with useful tools.

Conclusion

By following these steps, you’ll have a powerful development environment ready for infrastructure as code with Terraform, cloud management with AWS CLI, and coding with VS Code. Happy coding!

DEV Community: Victor Okonkwo

Multi-AZ Architecture for High Availability and Fault Tolerance

Key Components:

Deploying a Custom Web Application with Docker & Docker Compose on AWS EC2

Prerequisites

Step 1: Set Up an EC2 Instance & Install Docker

Step 2: Create a Web Application

Step 3: Create a Dockerfile

Step 4: Install Docker Compose

Step 5: Create a Docker Compose File

Step 6: Push the Image to Docker Hub

Step 7: Deploy on a New EC2 Instance

Deliverables

Setting Up a GitLab Server (Community Edition) and a GitLab Runner Using Docker Compose

Overview

Prerequisites

Install Docker

Install Docker Compose

Create the docker-compose.yml File

Start the Services

Troubleshooting Steps

Configure the GitLab Runner

Create a .gitlab-ci.yml File

Mastering Automation: An Introduction to Server Setup Scripting

Overview

Script Purpose

The Script

Explanation of Each Section

How to Run the Script

1. Save the Script

2. Make the Script Executable

3. Run the Script

4. Observe the Output

Why Automate Server Setup?

Conclusion

Guide: Building and Deploying a FastAPI App for Number Classification

1. Setting Up the FastAPI App

Steps to Build the App:

2. Configuring CORS for Web Access

3. Handling Asynchronous Requests

4. Running the App in the Background on Ubuntu EC2

Using nohup:

Alternatively, Using systemd:

5. Testing the API

Example cURL Request:

6. Documenting the API with Swagger

7. Best Practices for Deployment

Conclusion

DevOps Stage 0 - NGINX Configuration

Task Overview:

Step-by-Step Approach:

Challenges Faced:

Learning and Professional Development:

References:

Deploying a Scalable Web Application on AWS

Table of Contents

Part 1: Setting Up the EC2 Instance and Flask Application

Part 2: Configuring NGINX as a Reverse Proxy

Part 3: Integrating AWS RDS for Database

Part 4: Adding Auto-Scaling with Load Balancer

Part 5: Monitoring and Scaling with CloudWatch

Step 1: Log EC2 Application Data

Step 2: Enable Alarms

Step 3: Test Monitoring and Alarms

Recap

Part 6: Setting Environment Variables

Step 1: Set Environment Variables on Your EC2 Instance

Step 2: Update Your Flask App

Why Use These Approaches?

Documentation: Pushing and Pulling a Docker Image to Docker Hub

Step 1: Create a Docker Hub Account

Step 2: Prepare Your Docker Image

Step 3: Push the Image to Docker Hub

Step 4: Verify the Image on Docker Hub

Step 5: Pull the Image to Verify

Tips & Notes

Installing Docker and Deploying WordPress with MySQL (with WSL2)

Part 1: Installing Docker

Part 2: MySQL and WordPress Containers Deployment

Accessing WordPress

Create the `docker-compose.yml` File

Create a `.gitlab-ci.yml` File

Using `nohup`: