DEV Community: Matthew M Tarfa

Task Manager App with Flask and MySQL

Matthew M Tarfa — Sat, 16 Nov 2024 00:15:11 +0000

Project Overview

This project is a Task Manager App built with Flask and MySQL. It provides a simple RESTful API to manage tasks, demonstrating basic CRUD (Create, Read, Delete) operations.

This application is perfect for understanding how Flask applications can be containerized using Docker and connected with a MySQL database.

Features

Add new tasks
View all tasks
Delete a task by ID

Flask Code: app.py

from flask import Flask, request, jsonify
import mysql.connector
from mysql.connector import Error

app = Flask(__name__)

# Database connection function
def get_db_connection():
    try:
        connection = mysql.connector.connect(
            host="db",
            user="root",
            password="example",
            database="task_db"
        )
        return connection
    except Error as e:
        return str(e)

# Route for the home page
@app.route('/')
def home():
    return "Welcome to the Task Management API! Use /tasks to interact with tasks."

# Route to create a new task
@app.route('/tasks', methods=['POST'])
def add_task():
    task_description = request.json.get('description')
    if not task_description:
        return jsonify({"error": "Task description is required"}), 400

    connection = get_db_connection()
    if isinstance(connection, str):  # If connection fails
        return jsonify({"error": connection}), 500

    cursor = connection.cursor()
    cursor.execute("INSERT INTO tasks (description) VALUES (%s)", (task_description,))
    connection.commit()
    task_id = cursor.lastrowid
    cursor.close()
    connection.close()

    return jsonify({"message": "Task added successfully", "task_id": task_id}), 201

# Route to get all tasks
@app.route('/tasks', methods=['GET'])
def get_tasks():
    connection = get_db_connection()
    if isinstance(connection, str):  # If connection fails
        return jsonify({"error": connection}), 500

    cursor = connection.cursor()
    cursor.execute("SELECT id, description FROM tasks")
    tasks = cursor.fetchall()
    cursor.close()
    connection.close()

    task_list = [{"id": task[0], "description": task[1]} for task in tasks]
    return jsonify(task_list), 200

# Route to delete a task by ID
@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    connection = get_db_connection()
    if isinstance(connection, str):  # If connection fails
        return jsonify({"error": connection}), 500

    cursor = connection.cursor()
    cursor.execute("DELETE FROM tasks WHERE id = %s", (task_id,))
    connection.commit()
    cursor.close()
    connection.close()

    return jsonify({"message": "Task deleted successfully"}), 200

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

MySQL Database Setup Script

Create a MySQL script named init-db.sql to set up the database and the tasks table:

To create the init-db.sql script, follow these steps:

Create a new file in your project directory:

Navigate to the project folder and create a new file named init-db.sql
Add SQL commands to set up the database and tasks table:

Open init-db.sql in a text editor and add the following SQL commands:


CREATE DATABASE IF NOT EXISTS task_db;
USE task_db;

CREATE TABLE IF NOT EXISTS tasks (
    id INT AUTO_INCREMENT PRIMARY KEY,
    description VARCHAR(255) NOT NULL
);

Save the file:

I saved the file as init-db.sql in the project folder where my docker-compose.yml is located.

In the docker-compose.yml:

In my docker-compose.yml file, I have the volumes configuration that points to this script.

Below is the docker-compose.yml file

Docker Configuration

docker-compose.yml:

version: '3'
services:
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: task_db
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
      - ./init-db.sql:/docker-entrypoint-initdb.d/init-db.sql

  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      FLASK_ENV: development
    volumes:
      - .:/app

volumes:
  db_data:

This configuration ensures that when the MySQL container starts, it will execute the init-db.sql script to set up the task_db database and create the tasks table.

Note: The docker-entrypoint-initdb.d/ directory is used by MySQL containers to execute .sql scripts during the initial startup of the container.

Explanation:

1. version: '3': Specifies the version of Docker Compose being used.

2. services:

db:
- image: mysql:5.7: Uses the MySQL 5.7 image.
- environment: Sets environment variables for the MySQL container:
  - MYSQL_ROOT_PASSWORD: The root password for MySQL.
  - MYSQL_DATABASE: The database to be created at startup.
- ports: Maps the MySQL container's port 3306 to your host's port 3306.
- volumes:
  - db_data:/var/lib/mysql: Persists the database data in a Docker volume called db_data.
  - ./init-db.sql:/docker-entrypoint-initdb.d/init-db.sql: Mounts the init-db.sql script into the MYSQL container's initialization directory so it runs when the container starts.
web:
- build: .: Builds the Docker image for your Flask app using the Dockerfile in the current directory.
- ports: Maps the Flask app's port 5000 to your host's port 5000.
- depends_on: Ensures that the db service starts before the web service.
- environment: Sets the environment variable for Flask.
- volumes: Mounts the current project directory into the /app directory inside the container. ### volumes section: db_data: Defines a named volume db_data to persist the MySQL data between container restarts.

Dockerfile:

Define the build instructions for the Flask app:

FROM python:3.9-slim

WORKDIR /app

# Install dependencies

COPY requirements.txt .
RUN pip install -r requirements.txt

# Install wait-for-it tool#

RUN apt-get update && apt-get install -y wait-for-it

#Copy the application code>

COPY . .

# Use wait-for-it to wait for DB and start the Flask app

CMD ["wait-for-it", "db:3306", "--", "python", "app.py"]

This Dockerfile sets up a lightweight Python environment for a Flask app:

1. Base Image: Uses python:3.9-slim for minimal Python runtime.
Working Directory: Sets /app as the working directory.

2. Dependencies: Copies requirements.txt and installs dependencies via pip.

3. Tool Installation: Installs wait-for-it for checking service readiness.

4. Application Code: Copies all app code into the container.

5. Startup Command: Runs wait-for-it to ensure the MySQL DB (db:3306) is ready before starting app.py.

Requirements.txt File

This requirements.txt specifies that the Python project requires the Flask framework for building web applications and mysql-connector-python for connecting and interacting with a MySQL database. These packages will be installed within the Docker container when pip install -r requirements.txt is run during the image build process. This ensures the app has the necessary tools to run the Flask server and communicate with the MySQL database.

Flask
mysql-connector-python

After creating all the files the next step is to build and run the service the following command is used to build and run the service.

docker-compose build
docker-compose up

to run the service in a detached mode I used the following command instead of docker-compose up

docker-compose up -d

when I want to stop the service I use the command

docker-compose down

Now once the service is in the running state run the command

docker ps

to ensure the containers are running

Now its time to check the service API to ensure they are working as expected.

Testing the Project

Access the app at http://localhost:5000/ .
I was able to access the app on my browser after running the above command as seen in the image below.

You can use Postman or curl to test the /tasks endpoint for POST, GET, and DELETE operations. In ths case I would be using curl.

curl Commands:

Get Tasks:

The GET method fetches all tasks.

curl http://localhost:5000/tasks

Note that anytime you run http://localhost:5000/tasks on your browser it shows you all the task you have added as explained in the add task.

Add a Task:

The POST method creates tasks in the database.

curl -X POST http://localhost:5000/tasks -H "Content-Type: application/json" -d '{"description": "Sample Task"}'

This will send a POST request to your Flask app with a task description. If the task is added successfully, you should receive a response like:

{
    "message": "Task added successfully",
    "task_id": 1
}

check your browser's network tab or logs to verify that the POST request is being made correctly.

I ran the command a couple of times and customized the part where its says Simple Task to generate different outputs here are the commands I ran and the out puts can be seen in the images below.

 curl -X POST http://localhost:5000/tasks -H "Content-Type: application/json" -d '{"description": "My name is Matthew Tarfa am the Cloud Chief"}'

 curl -X POST http://localhost:5000/tasks -H "Content-Type: application/json" -d '{"description": "Welcome to my World!"}'

 curl -X POST http://localhost:5000/tasks -H "Content-Type: application/json" -d '{"description": "I love DevOps!"}'

Delete a Task:

The DELETE method removes tasks by ID.

curl -X DELETE http://localhost:5000/tasks/1

I ran the below command to remove the task with the ID:4 as seen in the image below task 4 has been removed.

curl -X DELETE http://localhost:5000/tasks/4

Conclusion

Creating a Task Manager App using Flask and MySQL is an excellent way to understand the fundamentals of web service development, database integration, and containerization with Docker.

This project encapsulates how web servers and databases work in unison to provide seamless functionality.

Embrace this learning experience and use it as a stepping stone to deeper web and cloud-based development projects.

Containerizing Python Data Processing Scripts with Docker: A Step-by-Step Guide

Matthew M Tarfa — Thu, 14 Nov 2024 05:54:29 +0000

Containerization is a game changer in modern software development, providing a consistent runtime environment for applications. In this blog post, I’ll guide you through a project where I containerized a Python script that reads and processes a CSV file using Docker. This is an excellent project for beginners looking to build a foundational understanding of Docker.

Project Overview

Goal: Containerize a Python script that processes data from a CSV file to make it portable and executable in any environment.
Technologies Used: Docker, Python, pandas

Real-World Application

This type of data processing can be scaled up for more complex datasets, such as processing customer records, analyzing survey results, or even preliminary data cleaning for machine learning tasks. The ability to containerize this script ensures that it can run consistently across various environments, making it easier for teams to collaborate without worrying about dependency issues.

Step 1: Create a Sample Data File

For this project, we will use a sample CSV file named data.csv with six simple entries:

data.csv content:

Name
Oluchukwu
Matthew
John
Sola
Benson
Winston

Step 2: Write the Python Script

Create a Python script named process_data.py to read and print a summary of the data.

process_data.py content:

import pandas as pd

# Creating a DataFrame from the CSV file
df = pd.read_csv('data.csv', header=None, names=['Name'])  # Assuming no header in the CSV file

# Generating the summary statistics of the 'Name' column
description = df['Name'].describe()

# Printing the description of the 'Name' column
print(description)

# Additional print to show unique value count explicitly
print("Unique values count:")
print(df['Name'].nunique())

Explanation of the Code:

Reading the CSV: The header=None argument tells pandas that the CSV doesn't have a header row, and the names=['Name'] argument assigns the name Name to the single column in the CSV.

Generating Summary: df['Name'].describe() gives you the summary statistics for the Name column, including count, unique values, the most frequent value (top), and its frequency (freq).

Printing Unique Values Count: df['Name'].nunique() directly shows the number of unique names in the column.

Step 3: Create a requirements.txt File

The requirements.txt file specifies the Python dependencies required by the script:

pandas

Explanation:
This ensures that the pandas library is installed when building the Docker image.

Step 4: Write the Dockerfile

The Dockerfile defines the environment and commands for building the container. Here’s what it should look like:

Dockerfile content:

# Use a minimal Python base image
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the required Python libraries
RUN pip install -r requirements.txt

# Copy the rest of the project files into the container
COPY . .

# Define the command to run the Python script
CMD ["python", "process_data.py"]

Explanation:

FROM python:3.9-slim: Specifies a lightweight Python image as the base.
WORKDIR /app: Sets the working directory for the container.
COPY requirements.txt . : Copies requirements.txt to the container.
RUN pip install -r requirements.txt : Installs Python dependencies.
COPY . . : Copies the project files into the container.
CMD ["python", "process_data.py"]: Specifies the command to run the script.

Step 5: Build the Docker Image

Navigate to the project directory and build the Docker image with the following command:

docker build -t python-script .

Explanation:

docker build: Command to build a Docker image.
-t python-script: Tags the image with the name python-script.
. (dot): Specifies the current directory as the build context.

Step 6: Run the Docker Container

Run the container and mount the data directory to ensure the script can access the CSV file:

docker run -v $(pwd)/data:/app/data python-script

Explanation:

docker run: Runs a Docker container.
-v $(pwd)/data:/app/data: Mounts the data directory from your host machine to /app/data in the container.
python-script: The name of the Docker image to run.

Step 7: Check the Output

After running the Docker container, you should see an output that summarizes the contents of data.csv. Here’s the actual output from the project

Output:

            Name
count          6
unique         6
top       Oluchukwu
freq           1
Unique values count:
6

Understanding the Output:

count: 6 – This shows that there are 6 values in the Name column. The count function counts the number of non-null entries, which is 6 in this case.
unique: 6 – This means that there are 6 unique names in the column. Since all 6 names provided (Oluchukwu, Matthew, John, Sola, Benson, Winston) are distinct, it counts all 6 as unique.
top: Oluchukwu – This tells that the most frequent name in the Name column. Since no name appears more than once in the file, pandas defaults to the first name in the column (in this case, Oluchukwu).
freq: 1 – This shows the frequency of the most frequent name, which is 1 because every name appears exactly once.
Unique values count: 6: This is showing that there are 6 unique names in the dataset, which matches the number of names in the CSV file.

Why Oluchukwu is listed as the top value:
In the dataset, no name is repeated, so pandas automatically picks the first name in the list, Oluchukwu, as the top value because it’s the most frequent by default.

6 unique names means there are 6 distinct entries, which is correct.
The top value of Oluchukwu is due to it being the first value in the list since there is no repetition.

Conclusion

By following these steps, you've successfully containerized a Python data processing script. This approach ensures that your script runs consistently across different environments, making it a valuable tool for data analysis tasks. You can further enhance this project by integrating it with cloud platforms or automating the container execution using CI/CD pipelines.

Next Steps:

Try expanding the script to include data cleaning, visualization, or exporting processed data. You can also explore deploying the container to a cloud service like AWS ECS or Kubernetes for a scalable data processing solution.

Ready to elevate your data processing projects? Start containerizing today and unlock the full potential of Docker!

Effortless Web Hosting: Build and Run an NGINX Server with Docker

Matthew M Tarfa — Wed, 13 Nov 2024 09:52:13 +0000

Introduction

Docker has transformed the way we deploy applications, making processes more efficient and consistent. Whether you're developing locally or deploying to production, Docker ensures your web server behaves the same way, regardless of where it’s running.

This guide will walk you through the process of creating an NGINX web server using Docker, providing a hands-on approach and practical insights along the way.

Why Use Docker for Your NGINX Web Server?
In traditional setups, creating an environment for your web server often involves installing and configuring software manually on each platform.

With Docker, you can package your server and its dependencies into a container that runs seamlessly anywhere. This approach is particularly useful for developers and DevOps engineers who need consistency across development, staging, and production environments.

Benefits of Using Docker:

Consistency:

Containers ensure your server runs the same way in all environments.

Portability:

Easily move your containerized server across various platforms and clouds.

Rapid Deployment:

Go from code to running application within minutes.

Step-by-Step Guide to Deploying an NGINX Web Server with Docker

Step 1: Set Up Your Project Directory

Start by creating a directory for your project. This will help keep all your files organized.

mkdir docker-project1
cd docker-project

Step 2: Create Your Web Content

Create a simple index.html file that will serve as the homepage for your web server.

touch index.html
nano index.html

Add some basic content to your index.html file:

**Step 3: Write Your Dockerfile*

The Dockerfile is the blueprint for building your Docker image. It contains instructions for setting up your environment. Create a Dockerfile in your project directory:

touch Dockerfile
nano Dockerfile

Add the following lines to your Dockerfile:

# Use the official NGINX base image
FROM nginx:alpine

# Copy the content of your HTML file to the default NGINX directory
COPY index.html /usr/share/nginx/html/index.html

Explanation of the Dockerfile:

FROM nginx : Specifies the lightweight NGINX base image to use.
COPY: Transfers your index.html file into the appropriate directory within the container.

Step 4: Build Your Docker Image

With your Dockerfile ready, build your Docker image by running:

docker build -t my-nginx-server .

This command creates an image named my-nginx-server based on your Dockerfile.

Step 5: Run Your NGINX Container

Start your container using the following command:

docker run -d -p 8080:80 my-nginx-server

-d: Runs the container in detached mode.
-p 8080:80: Maps port 8080 on your machine to port 80 inside the container.

Step 6: Access Your Web Server
Open your web browser and navigate to http://localhost:8080. You should see your "HTML!" message displayed, confirming that your NGINX server is up and running inside a Docker container.

Real-Life Use Case

Imagine a scenario where a software development team needs to quickly test changes to their website before deploying to production.

By containerizing their NGINX server, they can ensure that everyone on the team sees the same results locally as they would in a staging or production environment.

This dramatically reduces the risk of discrepancies due to "it works on my machine" issues.

Conclusion

Setting up an NGINX web server with Docker streamlines your deployment process, making it easier to create, test, and run web servers consistently across various environments.

This guide shows how simple it is to build and launch your server using Docker's powerful yet user-friendly tools.

Start using Docker for your projects today, and unlock a new level of efficiency and consistency in your deployments!

AWS Cost Optimization: A Practical Guide to Maximizing Efficiency

Matthew M Tarfa — Thu, 24 Oct 2024 14:49:52 +0000

In today's fast-paced tech landscape, where cloud computing has become the backbone of businesses, optimizing costs on cloud platforms like AWS is no longer a luxury—it's a necessity. While AWS offers a wide array of services that allow businesses to scale, it’s easy to lose track of costs when not managed properly.

AWS cost optimization is about making the most out of your cloud resources by using the right services, scaling intelligently, and eliminating waste. In this blog, we'll dive into practical scenarios, services, and strategies that can help organizations cut down on cloud expenditure while still leveraging the full potential of AWS.

Why AWS Cost Optimization Matters

For many organizations, moving to the cloud can feel like a never-ending financial commitment. Without proper planning, cloud bills can quickly spiral out of control. However, AWS provides tools and services that allow businesses to gain visibility into their cloud usage and make informed decisions that align with both technical and financial goals.

Here’s why cost optimization is crucial:

Financial Health: Reduced costs directly impact profitability.
Scalability: Efficient cost management allows more resources to be allocated for growth and innovation.
Sustainability: Cost optimization ensures that cloud resources are used sustainably, reducing waste.

Key AWS Services for Cost Optimization

AWS offers several services and tools that help businesses monitor and optimize their cloud spending. Here are some essential ones:

AWS Cost Explorer: Helps visualize and analyze cloud costs and usage patterns.
AWS Budgets: Allows users to set custom cost and usage budgets and receive alerts when they exceed thresholds.
AWS Trusted Advisor: Provides real-time recommendations, focusing on cost optimization, performance, and security.
AWS Compute Optimizer: Recommends optimal instance types based on usage to avoid over-provisioning.
AWS Lambda: Helps cut costs by charging based on the actual compute time used rather than reserved resources.
Amazon S3 Intelligent-Tiering: Automatically moves data to the most cost-effective storage tier based on access patterns.
Amazon RDS: Supports cost savings through Reserved Instances and by enabling automatic backups and data replication.

Real-Life Scenarios of AWS Cost Optimization

Let's look at some practical use cases of AWS cost optimization:

Scenario 1: EC2 Right-Sizing

Problem: A fast-growing e-commerce business runs multiple large EC2 instances that are rarely at full capacity, resulting in underutilization of resources.

Solution: By using AWS Compute Optimizer, they discover they can downsize several instances without affecting performance. They switch from expensive on-demand instances to Reserved Instances for their predictable workloads, saving up to 60% annually.

Impact: The business dramatically reduces its cloud bill while ensuring optimal resource use, allowing it to invest in marketing campaigns instead.

Scenario 2: Data Storage Optimization with S3

Problem: A media company stores petabytes of video data on Amazon S3 Standard, even though a large percentage of the data is rarely accessed.

Solution: Using S3 Intelligent-Tiering, the company automatically moves infrequently accessed data to lower-cost storage tiers, like S3 Glacier or S3 Deep Archive, where storage is significantly cheaper.

Impact: The company reduces storage costs by over 50% without any loss of data availability, freeing up funds for content creation.

Scenario 3: Serverless Architecture with Lambda

Problem: A startup uses EC2 instances to run a backend service, even though the service only receives intermittent traffic. During periods of low usage, they still pay for the idle EC2 instances.

Solution: They switch to a serverless architecture using AWS Lambda, which scales automatically and only charges them for actual compute time used.

Impact: The startup’s operational costs drop by 70%, allowing them to reinvest savings into R&D while maintaining application performance.

Scenario 4: Optimizing Database Costs with RDS Reserved Instances

Problem: A FinTech company runs several on-demand RDS instances for its production databases. The databases are always online and experience stable usage.

Solution: By transitioning to RDS Reserved Instances for its production databases, the company locks in lower pricing for a year.

Impact: The company achieves a 30% reduction in database costs, enabling it to scale other critical infrastructure like data pipelines.

Best Practices for AWS Cost Optimization

Here are some actionable tips to ensure you’re getting the most out of AWS without breaking the bank:

Right-Sizing Instances: Use AWS Compute Optimizer and Trusted Advisor to right-size your EC2, RDS, and other instance-based services. Over-provisioning resources is one of the most common mistakes businesses make.
Use Reserved Instances and Savings Plans: For predictable workloads, leverage EC2 Reserved Instances and Savings Plans to lock in lower rates. These can offer significant savings, especially for long-term, stable workloads.
Leverage Auto Scaling: Configure Auto Scaling for your applications to ensure you're not paying for unused capacity. Auto Scaling ensures that your environment scales in and out based on actual demand.
Monitor Unused Resources: Regularly audit your AWS environment for unused resources like idle EC2 instances, unattached EBS volumes, or outdated snapshots, and terminate or clean them up.
Use Cost-Effective Storage Solutions: Optimize your S3 costs by using S3 Intelligent-Tiering or S3 Glacier for long-term storage and infrequent access.
Optimize Lambda Usage: AWS Lambda can help reduce costs for intermittent workloads as it only charges for the time your code is executing. Ensure your Lambda function memory and execution time are optimized for further cost savings.

How Cost Optimization Impacts Business Growth

Optimizing AWS costs has direct and indirect impacts on business operations. Here’s how:

Scalability: Cost optimization allows you to reinvest savings into scaling your infrastructure, introducing new features, or improving service offerings.
Flexibility: With optimized costs, businesses have more room to experiment with new technologies and innovations without worrying about the financial burden.
Operational Efficiency: By eliminating unnecessary expenditures, organizations can streamline operations, making them more efficient and sustainable.
For instance, a business that reduces its EC2 costs by 40% could use those funds to implement new machine learning models, driving better customer engagement and business intelligence.

Final Thoughts

AWS cost optimization isn't about cutting corners; it's about maximizing the value of your cloud investment. By leveraging AWS’s wide range of services—such as Compute Optimizer, Reserved Instances, Lambda, and S3 Intelligent-Tiering—you can create a cloud environment that is both highly functional and financially efficient.

When done right, cost optimization doesn't just reduce expenses—it can drive growth, enable innovation, and improve the overall agility of your business. Start small, analyze your current usage patterns, and implement strategies incrementally. Your business will thank you for it in the long run.

Ready to start your AWS cost optimization journey? Explore these tools and strategies today and see the impact they can have on your business!

Elevating Excellence: Deploying a High-Performance LEMP Stack Web Server on AWS Cloud

Matthew M Tarfa — Tue, 12 Mar 2024 13:21:54 +0000

Introduction:

Embark on this exciting journey with me as I show you how to establish a robust web infrastructure on AWS, as I guide you through the meticulous process of deploying a LEMP (Linux, Nginx, MySQL, PHP) stack on the dynamic landscape of AWS Cloud. In this comprehensive guide, We'll lay the foundation for high-performance web applications, unlocking the full potential of cloud-based innovation.

STEP 1: Launching an EC2 Instance

We choose an Amazon Machine Image (AMI) for this project We would be using Ubuntu 22.04, select an instance type We would be using the t2 micro, configure instance details, add storage, and configure security groups to allow SSH (port 22) this grants us secured access into our instance and HTTP (port 80) traffic.

Review the settings and launch the instance.

Once the instance is running, connect to it using SSH. Use the private key associated with your key pair.

Step 2: Update server package index and Install the Nginx Web Server

To showcase our web pages to our visitors, we'll leverage Nginx, a high-performance web server. Utilizing the apt package manager, we'll streamline the installation process. As a first step, update our server's package index, and then proceed with installing Nginx using apt install.

sudo apt update
sudo apt install nginx

When prompted, enter 'Y' to confirm the Nginx installation. Once the installation is complete, the Nginx web server will be active on our Ubuntu 20.04 server. To confirm a successful installation and check the service status, run:

sudo systemctl status nginx

If the status is green and indicates that it's running, congratulations! We've successfully set up your first web server in the clouds. Well done!

To access the server locally from Git bash terminal use: curl http://localhost:80

Or curl http://127.0.0.1:80

Now to assess how our Nginx server responds to internet requests, enter your public IP address (http://Public-IP-Address:80) into a web browser. The format should resemble the following:

This shows that the web server is now correctly installed and accessible through our firewal

Step 3: Installing MySQL

With our web server operational, the next step is to install a Database Management System (DBMS) to store and manage data for our site. MySQL, a widely used relational database management system in PHP environments, will be our choice for this project. Let's proceed with its installation.

$ sudo apt install mysql-server

When prompted, confirm the MySQL installation by typing 'Y' and pressing ENTER.

Once the installation is complete, access the MySQL console by typing:

$ sudo mysql

MySQL settings and enhance security. Run the security script by executing:

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'PassWord1@';

where we have password1@ input your own reliable and strong password.

Exit the MySQL shell with:

mysql> exit

Start the interactive script by running:

$ sudo mysql_secure_installation

Accept the configuration of the VALIDATE PASSWORD PLUGIN when prompted this is if you want the existing password to be changed. Choose one of the three levels for the password validation policy, and then enter a new password corresponding to the selected policy level.
Subsequently, type 'Y' and press Enter at the following prompt. This action will remove any anonymous users and the test database, disable remote root logins, and implement the new rules to ensure that MySQL immediately incorporates the changes we've made.

When we are finished, we test if we are able to log in to the MySQL console by typing:

$ sudo mysql -p

Notice the -p flag in this command, which will prompt us for the password used after changing the root user password.

To exit the MySQL console, type:

mysql> exit

Notice that we need to provide a password to connect as the root user.

Step 4: Installing PHP

To process code and generate dynamic content, PHP needs to be installed alongside Nginx and MySQL.

Unlike Apache, which embeds the PHP interpreter in each request, Nginx requires an external program to handle PHP processing.

This program, called php-fpm (PHP FastCGI Process Manager), acts as a bridge between the PHP interpreter and the web server, enhancing overall performance for most PHP-based websites.

Additionally, installing php-mysql allows PHP to communicate with MySQL-based databases.

To install both packages simultaneously, execute the following command:

sudo apt install php-fpm php-mysql

Confirm the installation by typing 'Y' and pressing ENTER when prompted.

With the PHP components now installed, the next step involves configuring Nginx to utilize them effectively. Let's proceed with the configuration.

STEP 5: CONFIGURING NGINX TO USE PHP PROCESSOR

In Nginx, akin to Apache's virtual hosts, server blocks can host multiple domains on one server. For this guide, we'll use "projectLEMP" as an example domain.

By default, Ubuntu 20.04's Nginx serves from /var/www/html. Managing multiple sites is easier by creating domain-specific directories within /var/www. This leaves /var/www/html as the default directory for unmatched requests.

To create the root directory for "your_domain," follow these steps:

sudo mkdir /var/www/projectLEMP

Next, assign ownership of the directory with the $USER environment variable, which will reference our current system user:

sudo chown -R $USER:$USER /var/www/projectLEMP

opening a new configuration file in Nginx’s sites-available directory called projectLEMP:

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

Add the following script in the file created:

#/etc/nginx/sites-available/projectLEMP

server {
    listen 80;
    server_name projectLEMP www.projectLEMP;
    root /var/www/projectLEMP;

    index index.html index.htm index.php;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
     }

    location ~ /\.ht {
        deny all;
    }

}

Activate the configuration by linking to the config file from Nginx's sites-enabled directory:

sudo ln -s /etc/nginx/sites-available/projectLEMP /etc/nginx/sites-enabled/

Test the configuration for syntax errors:

sudo nginx -t

Disable the default Nginx host configured on port 80:

sudo unlink /etc/nginx/sites-enabled/default

Reload Nginx to apply the changes:

sudo systemctl reload nginx

Create an index.html file in the root web directory to test the new server block:

 $ sudo bash -c "echo -e 'Hello LEMP from hostname\n<h2>MATTHEW Cloud Force</h2>\n<h3>It is not the strongest of the species that survive, nor the most intelligent, but the one most responsive to change.</h3>' > /var/www/projectLEMP/index.html"

Now we go to our browser and try to open our website URL using IP address:

http://<Public-IP-Address>:80

We should see the below output

Our LEMP stack is now fully configured. In the next step, we'll create a PHP script to ensure that Nginx can handle .php files within our newly configured website.

STEP 5: TESTING PHP WITH NGINX

In this phase, we will examine the functionality of PHP within the Nginx environment to ensure seamless integration.To validate that Nginx can correctly hand .php files off to my PHP processor is by creating a test PHP file in the root web document:

Create a file called info.php:

nano /var/www/projectLEMP/info.php

Add the following script:

<?php
phpinfo();

To access this page in the web browser, use the following URL: http://Public_IP_address/info.php

After reviewing the pertinent information about our PHP server on that page, it's advisable to remove the file you created, as it contains sensitive details about our PHP environment and our Ubuntu server. We can use the rm command to delete that file:

sudo rm /var/www/projectLEMP/info.php

We can always regenerate this file if we need it later.

Step 7: Retrieving data from MySQL database with PHP

In this step, we'll create a test database (DB) with a simple "To-Do list" and configure access to it. This setup allows the Nginx website to query data from the DB and display it.

First is connecting to MySQL console:$ sudo mysql -p
Creating a new user and granting full privileges on the database using mysql_native_password as the default authentication method:

CREATE USER 'example_user'@'%' IDENTIFIED WITH mysql_native_password BY 'password';
GRANT ALL ON example_database.* TO 'example_user'@'%';

Replace 'example_user' with our desired username and 'password' with a strong and secure password. This ensures that the new user has the necessary permissions on the specified database. Here we would be using example-user as our username and PassWord1@ as our password. ensure the password meets the security password validation policy standard we selected earlier if not it would throw an error.

Exiting from MySQL console:mysql> exit

We can test if the new user has the proper permissions by logging into the MySQL console again, this time using the custom user credentials:

mysql -u example_user -p

Confirm that we have access to the example_database database:

mysql> SHOW DATABASES;

This will give you the following output:

Output
+--------------------+
| Database           |
+--------------------+
| example_database   |
| information_schema |
+--------------------+
2 rows in set (0.000 sec)

Next, we’ll create a test table named todo_list. From the MySQL console, run the following statement:

CREATE TABLE example_database.todo_list (
    item_id INT AUTO_INCREMENT,
    content VARCHAR(255),
    PRIMARY KEY(item_id)
);

Insert a few rows of content in the test table. We might want to repeat the next command a few times, using different VALUES:

mysql> INSERT INTO example_database.todo_list (content) VALUES ("My first important item");

To confirm that the data was successfully saved to our table, run:

mysql>  SELECT * FROM example_database.todo_list;mysql>  SELECT * FROM example_database.todo_list;

We should see the following output:

Output
+---------+--------------------------+
| item_id | content                  |
+---------+--------------------------+
|       1 | My first important item  |
|       2 | My second important item |
|       3 | My third important item  |
|       4 | Other Items on the List  |
+---------+--------------------------+
4 rows in set (0.000 sec)

After we confirm that we have valid data in our test table, we can exit the MySQL console:

mysql> exit

Creating a new PHP file named todo_list.php in our custom web root directory and generating a PHP script to connect to MySQL and query for our content can be achieved with the following command:

nano /var/www/projectLEMP/todo_list.php

This command opens the Nano text editor for you to create and edit the todo_list.php file.

Add the following PHP script:

<?php
$user = "example_user";
$password = "PassWord1@";
$database = "example_database";
$table = "todo_list";

try {
  $db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
  echo "<h2>TODO</h2><ol>";
  foreach($db->query("SELECT content FROM $table") as $row) {
    echo "<li>" . $row['content'] . "</li>";
  }
  echo "</ol>";
} catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
}

Save and close the file when we are done editing.

We can now access this page in our web browser by visiting the domain name or public IP address configured for our website, followed by /todo_list.php:

http://<Public_domain_or_IP>/todo_list.php

Congratulations!

In this guide, we've successfully established a versatile foundation for serving PHP websites and applications to our visitors.

Utilizing Nginx as the web server and MySQL as the database management system, we've created a robust environment ready to connect and interact seamlessly. Well done!

Harnessing the Power of AWS: Building a LAMP Stack Web Server for Your Website

Matthew M Tarfa — Wed, 21 Feb 2024 14:23:15 +0000

A technology stack is a thoughtfully assembled software tools, programming languages, frameworks, and libraries which are meticulously selected to collaboratively contribute to the development and maintenance of a well-functioning software. These stacks are often represented by acronyms, encapsulating the specific technologies harmoniously utilized in the creation of a tailored technology product. Some examples are.

LAMP (Linux, Apache, MySQL, PHP or Python, or Perl)
LEMP (Linux, Nginx, MySQL, PHP or Python, or Perl)
MERN (MongoDB, ExpressJS, ReactJS, NodeJS)
MEAN (MongoDB, ExpressJS, AngularJS, NodeJS)

In this blog, we'll guide you through the process of setting up a LAMP stack web server on the Amazon Web Services (AWS) platform, empowering you to deploy and host your web applications seamlessly.

Step 1: Launch an AWS EC2 Instance

To complete this project its expected that you already have an Amazon Account and know how to create an EC2 instance if you dont here is a link where you can learn this.
https://dev.to/cloudforce/getting-started-with-ec2-a-beginners-guide-to-launching-your-first-cloud-instance-23cg

Step 2: Configure Security Groups

When creating your EC2 instance, ensure to configure security groups to allow traffic on necessary ports. Open ports 22 (SSH), 80 (HTTP), and 443 (HTTPS) to enable remote access and web traffic.

Step 3: Connect to Your EC2 Instance

Once your instance is running, connect to it using SSH. You can use You can use a tool like PuTTY on Windows or the terminal on Linux/Mac.i would be using Git Bash. Also ensure that you have the private key corresponding to the key pair selected during instance creation.you will change directory (cd) to the directory where you saved the key, this will enable you SSH into the instance successfully.

Connect to the instance by running

ssh -i <private-key-name>.pem ubuntu@<Public-IP-address>

Step 4: Update Packages and Firewall

Update the package list installed on your instance using the below command:

sudo apt update

Step 5: Step 5: Install Apache2 Web Server

What exactly is Apache?

Apache is an open-source web server software widely used for hosting websites and applications, it is free. It runs in no less than 65% of the worlds servers. Its modular architecture, cross-platform compatibility, and community support make it a popular choice for serving web content. Apache's features include virtual hosting, security measures, and flexibility through customizable modules.

Install Apache using Ubuntu’s package manager ‘apt’:

#run apache2 package installation
sudo apt install apache2

To verify that apache2 is running as a Service in our OS, use following command

sudo systemctl status apache2

If its green and running then we did everything correctly.

We can also check our apache2 server locally in our ubuntu shell using the below command.

curl http://localhost:80
or
 curl http://127.0.0.1:80

We can also test how our Apache HTTP server can respond to requests from the Internet. Open a web browser of your choice and try to access following url

http://<Public-IP-Address>:80

Step 6: Install MySQL Database Server

MySQL is a widely used relational database management system (RDBMS) commonly employed in PHP environments. It facilitates the storage, retrieval, and management of structured data, playing a pivotal role in web application development. Known for its speed, reliability, and ease of integration with PHP, MySQL is a preferred choice for many developers building dynamic and data-driven websites.

Again, use ‘apt’ to acquire and install this software:

$ sudo apt install mysql-server

Confirm installation with 'Y' when prompted and press ENTER. After installation, log in to the MySQL console by typing:

$ sudo mysql

Exit the MySQL shell with:

mysql> exit

After installing MySQL, enhance security using the built-in script:

 $ sudo mysql_secure_installation

Configure the VALIDATE PASSWORD PLUGIN, choose a policy level, and set a corresponding new password. Confirm changes by selecting 'Y' and pressing Enter to remove anonymous users, disable remote root logins, and apply new rules for immediate effect.

If the password phase skipped then you would have to use the ALTER USER to set the password for the root user.

run this command

$ sudo mysql -p

Notice the -p flag in this command, which will prompt you for the password used after changing the root user password.
and since you were unable to set a pass word initially press enter.

Now run this command in mysql shell

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'PassWord1';

change password1 to your desired password ensuring the password meets the required password standard you have selected earlier.

Exit the MySQL shell with:

mysql> exit

Now, you have successfully set a password for the root user using the MySQL shell.

run this command input your new pass word and you are in.

mysql -u root -p

Step 7: Install PHP and Required Modules

Apache serves content, MySQL manages data, and PHP processes code for dynamic content display in our setup.

Besides the php package,we will install php-mysql for PHP and MySQL communication and libapache2-mod-php to enable Apache to handle PHP files. Core PHP packages will be automatically installed as dependencies.

To install these 3 packages at once, run:

sudo apt install php libapache2-mod-php php-mysql

Once the installation is finished, you can run the following command to confirm your PHP version:

php -v

At this point the LAMP stack is now fully installed and operational with Ubuntu Linux, Apache HTTP Server, MySQL, and PHP components successfully integrated.

We would take this a notch higher.

Step 8: Creating a Virtual Host for my Website using Apache

On Ubuntu 20.04, Apache comes with one default server block serving content from /var/www/html. To set up a virtual host, follow these steps:

Create a directory named "lampstackproject" for your domain with the command:

 $ sudo mkdir /var/www/lampstackproject

Assign ownership of the directory using the $USER environment variable to reference the current system user:

 $ sudo chown -R $USER:$USER /var/www/lampstackproject

Create and open a new configuration file in Apache's sites-available directory using:

 $ sudo nano /etc/apache2/sites-available/lampstackproject.conf

Paste the desired configurations into the opened file.

<VirtualHost *:80>
        ServerName projectlamp
        ServerAlias www.projectlamp 
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/projectlamp
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Save and exit by pressing the "Ctrl + O " key, press "enter", and then pressing the "Ctrl + X " then press "Enter" key.

Enable the new virtual host with the command: $ sudo a2ensite projectlamp

Disable the default website installed with Apache using: $ sudo a2dissite 000-default

Ensure there are no errors in the configuration by running: $ sudo apache2ctl configtest

Reload Apache to apply the changes with the command: $ sudo systemctl reload apache2

Create an index.html file in your domain directory to test the virtual host with:

 $ sudo bash -c "echo -e 'Hello LAMP from hostname\n<h2>MATTHEW Cloud Force</h2>\n<h3>It is not the strongest of the species that survive, nor the most intelligent, but the one most responsive to change.</h3>' > /var/www/lampstackproject/index.html"

To test if your virtual host is working as expected, you can open your web browser and enter your server's IP address. In this case, it would be the public IP address of your AWS instance.

If everything is set up correctly, you should see the content you added to the index.html file, including the formatted text and headings.

STEP 9: Enabling PHP on the website

The default DirectoryIndex settings on Apache prioritize index.html over index.php. This feature is beneficial for creating temporary maintenance pages in PHP applications.

By crafting a brief message in a temporary index.html file, it takes precedence over index.php, serving as the landing page during maintenance.

After completing the maintenance, the index.html can be renamed or removed from the document root, restoring the regular application page.

If you wish to modify this behavior, you must edit the /etc/apache2/mods-enabled/dir.conf file and adjust the order of the index.php file within the DirectoryIndex directive.

sudo nano /etc/apache2/mods-enabled/dir.conf

<IfModule mod_dir.c>
        #Change this:
        #DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm
        #To this:
        DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>

Upon saving and closing the file, it is necessary to reload Apache for the modifications to become effective:

sudo systemctl reload apache2

create an index.php file and add a PHP script to test the installation and configuration of PHP on your server

nano /var/www/projectlamp/index.php

This will open a blank file. Add the following text, which is valid PHP code, inside the file:

<?php
phpinfo();

Once you've made the changes, save and close the file. Afterward, refresh the page in your web browser, and you should observe a page resembling this:

Remove the PHP file as it contains sensitive information, use the following command:

sudo rm /var/www/lampstackproject/index.php

This command deletes the index.php file from the specified directory.

Congratulations! You've successfully completed a real-life project by deploying a LAMP stack website in the AWS Cloud! This achievement not only demonstrates your technical prowess but also sets the stage for hosting and deploying dynamic web applications. As you continue, consider expanding your server's capabilities, fortifying its security, and confidently deploying future web projects.

May the Cloud Force Be with you!

Transforming Organizations The Power of DevOps Excellence

Matthew M Tarfa — Tue, 20 Feb 2024 12:26:49 +0000

In the rapidly evolving landscape of technology, DevOps stands out as a revolutionary force, reshaping how organizations approach application delivery. Beyond a set of practices, DevOps embodies a cultural transformation that prioritizes collaboration, automation, and continuous improvement. In this blog, we explore the essence of DevOps and elucidate why it is not a fleeting trend but an essential strategy for organizations seeking agility and excellence.

Breaking Down the Basics of DevOps: A Cultural and Practical Evolution.

At its core, DevOps transcends mere methodology; it embodies a cultural shift that amplifies the entire application delivery spectrum. Picture a synchronized ballet where automation, meticulous quality assurance, perpetual monitoring, testing and collaborative efforts converge to create a symphony of precision, efficiency and dependability.

The Rise of Automation: A Departure from Manual Prowess

Reflecting on the past, the manual intricacies of application delivery were akin to a slow waltz, prolonging the delivery timelines. DevOps, however, introduces a dynamic and swift tango, embracing change and innovation, now Automation rules!

This metamorphosis signifies not just a progression but a leap into a realm where efficiency and reliability coalesce seamlessly.

In this era of rapid technological advancement, the DevOps symphony emerges as the avant-garde, shaping a new narrative for organizations seeking excellence in application delivery.

The evolution is not merely a response to change; it is a deliberate and strategic stride where efficiency, reliability, and innovation take center stage.

Driving Innovation: The Key Tenets of DevOps

Efficiency Enhancement: DevOps propels organizations towards efficiency by automating workflows, eliminating manual tasks, and expediting development cycles, resulting in a more rapid and dependable software delivery.
Collaboration Augmentation: Breaking down silos, DevOps fosters collaboration between development and operations teams, enriching communication, understanding, and overall alignment to create a cohesive working environment.
Continuous Delivery and Deployment: Embracing continuous integration and continuous delivery (CI/CD), DevOps empowers organizations to release software updates swiftly, enhancing the agility of development teams and ensuring consistent deployment.
Quality Assurance: DevOps places a premium on continuous testing and quality assurance throughout the development lifecycle, yielding higher-quality software, reducing defects, and safeguarding against issues reaching production.
Customer Satisfaction: Swift delivery of features and bug fixes enables organizations to meet and exceed customer expectations, responding promptly to market demands and fostering increased customer satisfaction.
Risk Mitigation: Through automated testing and continuous monitoring, DevOps identifies and addresses issues early in the development process, proactively minimizing the risk of major defects or failures in production.
Innovation and Flexibility: DevOps nurtures a culture of experimentation and innovation, empowering teams to explore new ideas and technologies, fostering a continuous improvement mindset and adaptability to changing business needs.
Cost Optimization: The automation and efficiency gains achieved through DevOps translate into tangible cost savings by minimizing manual processes and downtime, optimizing resource utilization, and achieving operational cost efficiencies.
Employee Engagement and Retention: DevOps cultivates a collaborative and inclusive work environment, instilling a sense of ownership and achievement among team members, contributing to higher employee satisfaction and retention.
Competitive Edge: Organizations embracing DevOps gain a strategic advantage by responding swiftly to market changes. The ability to deliver high-quality software faster becomes a defining factor in today's competitive business landscape.

Conclusion: Embrace DevOps, Propel Excellence

DevOps transcends a set of practices; it embodies a cultural and practical evolution propelling organizations towards excellence.

By championing collaboration, automation, quality and continuous improvement, DevOps emerges not as a transient trend but as an essential strategy for organizations aspiring to thrive in the dynamic digital era.

The journey towards DevOps excellence is not just a choice; it is a definitive step towards a future where agility, innovation, and reliability converge, propelling organizations to unparalleled heights.

Getting Started with EC2: A Beginner's Guide to Launching Your First Cloud Instance.

Matthew M Tarfa — Tue, 20 Feb 2024 08:47:34 +0000

Amazon Elastic Compute Cloud (EC2) is a highly scalable and versatile cloud computing service provided by Amazon Web Services (AWS). EC2 allows you to launch and manage virtual servers, known as instances, in the AWS cloud. In this blog post, we will walk you through the step-by-step process of creating an EC2 instance, enabling you to set up and configure your own virtual server within the AWS ecosystem.

Prerequisites:

Before we begin, ensure that you have the following prerequisites:

An active AWS account.
Familiarity with the AWS Management Console.
Basic understanding of networking concepts and security groups.

Accessing the EC2 Dashboard:

Log in to the AWS Management Console.
Navigate to the EC2 service by clicking on "Services" and selecting "EC2" from the list of services or you could type EC2 in the search bar, here select EC2 from the options provided.

On the EC2 dashboard, click the "Launch Instance" button to initiate the instance creation process.

Give your EC2 a name, give it a unique name to help you differentiate your instances.

Choose an Amazon Machine Image (AMI) based on your requirements. This serves as the operating system for your instance, here we have selected Ubuntu under the free tier eligible.

when you register an account with AWS for the first year you are allowed access to some services for free this is one of those services.

Select an instance type that aligns with your desired computing resources, such as CPU, memory, and storage capacity, for the purpose of writing this blog I would stick to the free tier t2 micro.

Create New Key Pair :

Select an existing key pair or create a new one. A key pair is necessary to securely access your EC2 instance using Secure Shell (SSH).

If creating a new key pair, follow the instructions to generate and download the private key file (.pem). Keep this file in a secure location.

I will be creating a new key pair to demonstrate how it is done.

Click on create new key Pair.

First, you give your key pair a name, and you select the key pair type.

In this blog, we would not be going into the details of the difference between the two key pair types available but we would go with the RSA key pair type.

click on Create key pair to continue, this automatically creates a key pair and downloads a pem file into your downloads.

We now have a key pair.

Network Setting:

Network Settings for this blog we would leave it as the default, AWS provides every account on the AWS platform with default VPC settings so we would work with that.

Configure Security group(firewall)

Configure security groups to control inbound and outbound traffic for your instance.

We would create a new security group for this EC3 instance we are creating

we would allow port 22 which allows secured traffic via SSH also HTTPS connections which use TCP port 443 and HTTP, the unsecured protocol, uses port 80 these are all inbound rules.

Other Configurations :

We would go ahead to configure other instance details, including the number of instances, and storage options. for the purpose of this blog, we would leave the number of instances at one and for the storage option, we would also leave it as default.

Review the instance configuration and make any necessary adjustments.

If creating a new key pair, follow the instructions to generate and download the private key file (.pem). Keep this file in a secure location.

Once you have reviewed the instance details, click "Launch" to initiate the creation of your EC2 instance.

EC2 Dashboard:

The instance creation process will commence. You can monitor the progress and view the instance status on the EC2 dashboard.

After initialization, you check if your instance is healthy by confirming that you have 2/2 checked and passed.

Conclusion:

Congratulations! You have successfully created an EC2 instance on AWS.

By following the comprehensive steps outlined in this guide, you have gained the knowledge to launch and configure your own virtual server within the AWS cloud.

Remember to monitor and manage your instances using the EC2 dashboard, and explore additional AWS services to enhance the functionality and scalability of your EC2 instances.

We hope this comprehensive guide has provided you with a clear understanding of the process involved in creating an AWS EC2 instance.

Embrace the power of EC2 to meet your computing requirements in the cloud, and unlock the potential of AWS for your business needs. Happy cloud computing!