DEV Community: Emmanuel Oghre

Deploying an NGINX Web Server on AWS EC2- Stage Zero (0) Project

Emmanuel Oghre — Wed, 29 Jan 2025 15:15:22 +0000

Introduction
This marks the start of my DevOps journey at HNG Cohort 12.

I was tasked with setting up and configuring NGINX on a fresh Ubuntu server. This task will demonstrate my ability to work with basic web server configurations and deliver a functional web server.
🔧Task Requirements:

NGINX Installation and Configuration

Install the NGINX web server and ensure it is running.
Configure NGINX to serve a custom HTML page as the default page (/var/www/html/index.html)

Prerequisite for this Project

Setup a Cloud Platform Account
Download and install a SSH Client
Foundational knowledge of edit files in Linux Command Line Interface.

Step 1

Launch AWS account and create an Ubuntu server
Login into the AWS console and click on EC2 (Elastic Compute Cloud)

Click on launch instance to start a fresh spin-up a new AWS instance

Type in a name for the server and choose any Ubuntu server image provider and type, in this case I am choosing Ubuntu 24.04 LTS(HVM), SSD Volume Type

Finalize other prerequisite such as assigning a key-pair and network configuration. I have chose to create a new security group and allow inbound connection on port 80 and 22.

Port 80: allows me to view webpages using the browser connected to the internet, servers responds to client's request via the
80 protocol** which is an application layer protocol primarily used via a web browser.
Port 22: allows me to connect to my server instance to make configurations. It is a secured way to connect to a server via the internet.

Building Your DB Server and Interacting With Your DB Using an App on AWS

Emmanuel Oghre — Tue, 02 Jul 2024 10:05:30 +0000

Welcome to another AWS lab walkthrough! In this session, we'll guide you through setting up a relational database server on Amazon RDS and interacting with it through a web application. By the end of this lab, you'll have a fully functional setup where your database is not only deployed but also actively serving a web application.

Overview
Lab Title: Build Your DB Server and Interact With Your DB Using an App
AWS Version: 4.6.6 (TESS2)
Duration: Approximately 30 minutes

Scenario

At the end of the lab the infrastructure will look like this.

Objectives
After completing this lab, you will be able to:

Launch an Amazon RDS DB instance with high availability.
Configure the DB instance to permit connections from your web server.
Open a web application and interact with your database.
Scenario
Imagine you start with a basic infrastructure setup, and through this lab, you'll evolve it into a more robust architecture capable of hosting a scalable and resilient database solution.

Step-by-Step Guide
Task 1: Create a Security Group for the RDS DB Instance
Navigate to VPC: In the AWS Management Console, go to Services > VPC.
Create Security Group: Click on Security Groups in the left pane and then Create security group.
Security group name: DB Security Group
Description: Permit access from Web Security Group
VPC: Lab VPC
Configure Inbound Rules: Add a rule to permit inbound database requests.
Type: MySQL/Aurora (3306)
Source: Type "sg" and select Web Security Group.
Create Security Group: Finish by clicking Create security group.
Task 2: Create a DB Subnet Group
Navigate to RDS: In the AWS Management Console, go to Services > RDS.
Create DB Subnet Group:
Click on Subnet groups in the left pane and then Create DB Subnet Group.
Name: DB-Subnet-Group
Description: DB Subnet Group
VPC: Lab VPC
Add Subnets:
Select subnets from at least two Availability Zones (e.g., us-east-1a and us-east-1b).
Choose subnets associated with CIDR ranges like 10.0.1.0/24 and 10.0.3.0/24.
Create DB Subnet Group: Click Create.
Task 3: Create an Amazon RDS DB Instance
Launch RDS Instance:
In the RDS console, click Databases in the left pane and then Create database.
Select MySQL under Engine Options.
Choose Dev/Test under Templates.
Select Multi-AZ DB instance for Availability and durability.
Configure Settings:
DB instance identifier: lab-db
Master username: main
Master password: lab-password
DB instance class: db.t3.micro
Allocated storage: 20 GB
Virtual Private Cloud (VPC): Lab VPC
Security group: Select DB Security Group.
Additional Configurations:
Initial database name: lab
Uncheck Enable automatic backups and Enable encryption for lab purposes.
Create Database: Click Create database.
Task 4: Interact with Your Database
Access Web Server IP: Retrieve the IP address of your web server from the AWS console.
Open Web Application: Paste the WebServer IP address into a browser tab and press Enter.
Navigate to the RDS link displayed on the page.
Configure Database Connection:
Enter the Endpoint (copied from RDS console earlier).
Database: lab
Username: main
Password: lab-password
Click Submit.
Test Application: The web application should display an Address Book.
Add, edit, and remove contacts to verify database functionality.

Note!!! You can configure the password, admin and database name as you see fit

Conclusion
Congratulations! You have successfully completed the lab. You've learned how to deploy a high-availability RDS database instance on AWS, configure security settings, and integrate it with a web application. This setup ensures your database is not only robust but also scalable and fault-tolerant, suitable for various production workloads.

For more AWS tips and guides, stay tuned to our blog or explore further in the AWS documentation. Happy cloud computing!

With this guide, you're now equipped to handle AWS RDS deployments and database interactions like a pro. Let me know if you have any questions or need further assistance!

Getting Started with Docker and Kubernetes Sandboxes (Day 3)

Emmanuel Oghre — Mon, 24 Jun 2024 10:21:32 +0000

This post builds on the concepts covered in Day 2's video and assumes you already have Docker. If you haven't, you can use these resources:

Docker Sandbox: Link
Kubernetes Sandbox: Link
Download Docker Desktop: Link

Docker multi-stage builds have several advantages over traditional single-stage builds. They're pretty cool, actually!

First off, you can make your images smaller. How? Well, by splitting the build process into stages, you can leave out all the stuff that's not needed in the final image. You know, things like build dependencies and compilers that the application itself doesn't need to run. So, only the essential application artifacts end up in the slimmed-down image. That means smaller images that don't take up much storage space or time to download. Neat, right?

But wait, there's more! These multi-stage builds also beef up your security. Smaller images mean there's less room for attackers to find vulnerabilities. By getting rid of unnecessary components, you're reducing the potential weak spots that bad guys can exploit. Safety first!

Another perk is faster builds. Docker can cache intermediate images created during the build process. So, if the build instructions in a particular stage haven't changed, Docker can just reuse the cached image instead of rebuilding it from scratch. This can really speed things up, especially for complex applications. Time is money, my friend!

And let's not forget about enhanced maintainability. Breaking down the build process into stages makes it easier to read and tweak your Dockerfile. Each stage focuses on a specific task, so you can understand and modify the process without any headaches. It's all about simplicity and keeping things organized.

So, to sum it all up, Docker multi-stage builds are an awesome technique for creating lean, secure, and efficient Docker images.

Demo Setup
Clone the sample repository (or use your own web application):

git clone https://github.com/piyushsachdeva/todoapp-docker.git
cd todoapp-docker/

Create a Dockerfile and paste the content provided in the video.

FROM node:18-alpine AS installer
WORKDIR /app
COPY package*.json ./
RUN npm install 
COPY . .
RUN npm run build
FROM nginx:latest AS deployer
COPY --from=installer /app/build /usr/share/nginx/html

Build the Docker image:

docker build -t todoapp-docker .

Verify the image is built:

docker images

Pushing the Image to a Public Repository

Create a public repository on https://hub.docker.com/.

docker login

Tag your image with your username and repository details:

docker tag todoapp-docker:latest username/new-reponame:tagname

Push the image:

docker push username/new-reponame:tagname

Running the Container Locally

Pull the image from your repository (if running on another machine):

docker pull username/new-reponame:tagname

Start the container and map port 3000:

docker run -dp 3000:3000 username/new-reponame:tagname

Access your app at http://localhost:3000 (if successful).

Additional Commands

Entering Container:

docker exec -it containername sh

(or use container ID)

Viewing Logs:

docker logs containername

(or use container ID)

Inspecting Container:

docker inspect containername

Cleaning Up Images:

docker image rm image-id

_Refer to the CKA2024 Series by Piyush Sahdeva
Github Repo: Link
This post provides a basic overview of the commands covered in the video. Refer to the video for detailed explanations and troubleshooting. Happy coding!
_

Day 2/40 CKA Dockerize an Application

Emmanuel Oghre — Sun, 23 Jun 2024 12:36:01 +0000

Dockerizing Your Project: A Step-by-Step Guide
Docker is an essential tool for modern software development, providing a consistent and isolated environment for your applications. In this guide, we will walk you through the process of dockerizing a sample Node.js application. By the end, you will have a Docker image that you can run anywhere, ensuring your application behaves the same in all environments.

Prerequisites
Docker Desktop: Download and install the Docker Desktop client from Docker's official website.
Simplify Setup: By providing a starting point, docker init helps developers get up and running with Docker more quickly, reducing the initial setup time and effort.

Sample Application: We will use a sample application for this demo. You can clone it from GitHub or use your project.
Step 1: Clone the Sample Repository
First, clone the sample repository:

git clone https://github.com/docker/getting-started-app.git
cd getting-started-app/

Step 2: Create a Dockerfile
A Dockerfile is a text file that contains instructions on how to build a Docker image. Create an empty Dockerfile in your project directory:

touch Dockerfile

Using your preferred text editor, open the Dockerfile and add the following content:

Dockerfile

# Use the official Node.js 18 image from the Docker Hub
FROM node:18-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy all files from the current directory to the working directory in the container
COPY . .

# Install dependencies using yarn
RUN yarn install --production

# Specify the command to run the application
CMD ["node", "src/index.js"]

# Expose port 3000 to the host
EXPOSE 3000

Step 3: Build the Docker Image
With the Dockerfile in place, you can build the Docker image. Run the following command in your terminal:


docker build -t day02-todo .

This command tells Docker to build an image named day02-todo using the instructions in the Dockerfile.

Step 4: Verify the Image
After the build process completes, verify that the image has been created and stored locally:


docker images

You should see day02-todo listed among the available images.

Step 5: Push the Image to Docker Hub
To share your Docker image with others or deploy it to another environment, push it to Docker Hub. First, log in to Docker Hub:

docker login

Tag the image with your Docker Hub username and repository name:

docker tag day02-todo:latest username/new-reponame:tagname

Push the image to Docker Hub:

docker push username/new-reponame:tagname

Step 6: Pull the Image to Another Environment
To use the image in another environment, you can pull it from Docker Hub:

docker pull username/new-reponame:tagname

Step 7: Run the Docker Container
Start a container from your Docker image:

docker run -dp 3000:3000 username/new-reponame:tagname

This command maps port 3000 of your host machine to port 3000 of the container, allowing you to access the application locally.

Step 8: Verify the Application
If everything was set up correctly, your application should be running and accessible at http://localhost:3000.

Step 9: Access the Container
If you need to enter the container for debugging or other purposes, use the following command:


docker exec -it containername sh

Replace containername with the actual name or ID of your running container.

Conclusion
Congratulations! You have successfully dockerized a Node.js application. This Docker image can now be run anywhere, ensuring a consistent environment across development, testing, and production. For further exploration, consider using sandbox environments like Play with Docker or Play with Kubernetes.

Kindly refer:
youtube playlist CKA Full Course 2024 by Piyush Sachdeva for more hands-on.
Github Link: https://github.com/Emmy-code-dev/CKA-2024

Happy Dockerizing!

🚀Unlock the Power of Docker for Your DevOps Workflow!🚀

Emmanuel Oghre — Wed, 19 Jun 2024 15:44:46 +0000

What is Docker? Docker is a game-changing lightweight sandbox environment that packages your application along with its libraries, runtime, and dependencies. This equips your app with everything it needs to run in isolation, making the deployment process seamless. This revolutionary concept is known as containerization, and Docker is at the forefront of this technology.
While Docker leads the charge, there are other noteworthy containerization technologies such as Podman, Containerd, Nerdctl, LXC, runc, and Red Hat OpenShift.

Why Docker? Have you ever faced the nightmare of an app working flawlessly in the development and test environments but crashing in production? This common issue stems from misconfigurations, misalignments, and functionality problems when moving between different environments. Such discrepancies often lead to conflicts between development teams (who create the app) and operations teams (who manage infrastructure).

Enter Docker — The Ultimate Solution Docker addresses these challenges by allowing you to ship your code to the production environment with all necessary libraries and dependencies. This eliminates misconfigurations, infrastructure misalignments, networking issues, and unhealthy infrastructure, ensuring your app runs smoothly anywhere. Containerization thus empowers your applications to operate in isolated environments with everything they need to succeed.

Streamlining Containerization Tasks Here’s how Docker simplifies your workflow:
Build ➡️ Ship ➡️ Run Application Code
Simple Docker Flow:
Install Docker: Download and install Docker on your local machine from the official Docker website.
Create a Dockerfile: Write a Dockerfile that defines the environment for your application. This typically includes:
A base image (FROM)
Instructions to add the application code (COPY or ADD)
Commands to install dependencies (RUN)
Command to run the application (CMD or ENTRYPOINT)
Build the Docker Image: Use the docker build command to create an image from your Dockerfile.
Push Created Image to Registry: Push your image to a registry like Docker Hub.
Pull Image from Registry: Use the docker pull command to pull the image into your dev, test, and production environments.
Run the Docker Container: Use the docker run command to see if your application is running as expected.

Docker transforms how we develop, test, and deploy applications, making the process efficient, consistent, and error-free. Dive into the world of Docker today and revolutionize your DevOps workflow! 🌟

👉 Video Link: https://lnkd.in/dwvdsaGw
👉 GitHub Link: https://lnkd.in/dRu983VZ