Forem: Uyi Oboite

Deploying Nginx on Azure Ubuntu VM: My Experience

Uyi Oboite — Thu, 30 Jan 2025 16:03:53 +0000

Introduction

Deploying Nginx on an Azure virtual machine (VM) was a great learning experience that strengthened my understanding of cloud infrastructure, Linux server management, and networking configurations. This blog post details my approach, challenges encountered, solutions applied, and how this task aligns with my professional goals.

Nginx is a web server, meaning it serves web content, handles HTTP requests, and acts as a reverse proxy. Reverse proxy means a server or application that functions as an intermediary between clients and actual web servers, intercepting incoming requests from clients, forwarding them to the appropriate backend server, and then sending the response back to the client.

Also note that Nginx as a web server needs an operating system to run, reason I am deploying it on an Azure Ubuntu VM.

My Approach

Here is a step-by-step breakdown of how I completed the task:

1.Creating an Azure Resource Group and Virtual Machine

The first step was to set up an Azure resource group to keep all project-related metadata organized. Then, I created an Ubuntu-based VM to host my Nginx installation.

2.Connecting to the Azure VM

After deploying the VM, I used the following command to log in to my Azure account from the Ubuntu terminal:

                 az login

Once authenticated, I established an SSH connection to the VM using:

           ssh username@<VM_IP_Address>

3.Updating System Packages
To ensure that my system was up to date, I ran:

      sudo apt update && sudo apt upgrade -y

The -y flag automatically confirmed the installation of package updates.

4.Installing Nginx
I installed Nginx using:

         sudo apt install nginx -y

5.Starting and Enabling Nginx
Once installed, I started the Nginx service and enabled it to start on boot:

       sudo systemctl start nginx
       sudo systemctl enable nginx
       sudo systemctl status nginx

A successful installation was confirmed when the output displayed active (running).

6.Verifying Nginx Installation
To verify that Nginx was running correctly, I opened my browser and navigated to

         http://<VM_IP_Address>/

I was greeted with the default Nginx welcome page, confirming that the server was working.

7.Customizing the Default Nginx Page
To replace the default Nginx welcome page, I edited the HTML file located at /var/www/html/index.html:

        sudo vim /var/www/html/index.html

I replaced the default content with:

<h1>Welcome to DevOps Stage 0 - Uyiosa Praise Oboite/Uyi</h1>

Then, I saved the changes and restarted Nginx to apply them:

        sudo systemctl restart nginx

To confirm the update, I reloaded the browser at http:/// and saw my custom message displayed.

Challenges and Resolutions

1.SSH Connection Failure on Port 22

Issue: Initially, I couldn't SSH into the VM because the connection timed out.

Resolution: I updated the VM's Network Security Group (NSG) inbound rules to allow traffic on port 22.

2. Permission Issues When Editing the Nginx HTML Page

Issue: I encountered a permission error when trying to edit /var/www/html/index.html.

Resolution: I used superuser privileges (sudo) before editing the file:

       sudo vim /var/www/html/index.html

Key Takeaways

Completing this task reinforced my understanding of:

Cloud infrastructure management using Azure.
Linux system administration (package management, service control, and file editing).
Networking configurations (SSH and NSG rules).
Web server deployment using Nginx.

This knowledge directly supports my career aspirations in DevOps and Cloud Engineering, providing foundational skills for automating infrastructure and managing cloud-hosted applications.

References

DevOps Engineers
Cloud Engineers
Site Reliability Engineers

Author

Uyiosa Praise Oboite
LinkedIn Profile

Real-Time Monitoring Dashboard Project Using FastAPI and Azure

Uyi Oboite — Thu, 19 Sep 2024 15:26:08 +0000

Project Overview

This application monitors system metrics (CPU, memory, and disk usage) in real-time and provides visual representations via an HTML interface. The project was developed using FastAPI for the backend and Jinja2 for dynamic HTML rendering. The application is hosted on Azure App Service, making it scalable and easily accessible from anywhere.

Technologies Used

FastAPI: Lightweight web framework used to build APIs quickly and efficiently.
Uvicorn: Lightning-fast ASGI server for serving the FastAPI application.
Jinja2: Template engine for rendering HTML dynamically based on system metrics.

File Structure

1. monitoring_app.py:
The main FastAPI application that handles system metrics and renders the HTML templates.

This is the main Python file where the FastAPI application is defined.
It contains the endpoints for retrieving system metrics (CPU, memory, and disk usage) using the psutil library.
The application uses the Jinja2 templating engine to render HTML pages dynamically, displaying the system metrics in a clean format.

requirements.txt: This file lists all the dependencies needed to run the project. Key dependencies include FastAPI for building the web framework, Uvicorn for running the app, Psutil for retrieving system metrics, and Jinja2 for rendering HTML templates.

3. templates/:
This directory contains the HTML files used to display system metrics.

home.html:
- This is the template displayed when a user visits the root endpoint /.
- It can include a welcome message and provide navigation to the metric pages (CPU, memory, disk).

cpu_usage.html:
- Displays the current CPU usage in a styled, centered format.

memory_usage.html
- Displays the current memory usage (total, available, and percentage used)
disk_usage.html
- Displays the disk usage (total, used, free, and percentage used).

How It Works

FastAPI for the Backend: The backend is built with FastAPI to serve system metrics through different endpoints (/metrics/cpu, /metrics/memory, /metrics/disk).
Jinja2 for Rendering: The system metrics are passed to the Jinja2 templates, which dynamically generate HTML pages. For example, the CPU usage is rendered with the current percentage centered and styled using CSS.
Azure Deployment: The application is deployed on Azure App Service, providing a highly available and scalable environment

Azure Deployment Process

The following steps outline how I deployed my FastAPI Monitoring Application to Azure App Service, making use of the Azure CLI to automate the process and configure the deployment.

Install Necessary Python Packages

Before starting the deployment process, I installed the necessary dependencies, including FastAPI, Uvicorn, jinja2 and Psutil

Create an Azure Resource Group

An Azure Resource Group is a container that holds related resources for an Azure solution. To create the resource group, I used the following command

monitoring-app-rg: This is the name of the resource group.
eastus: The Azure region where the resources are hosted

Create an Azure App Service Plan

An App Service Plan defines the region, size, and scale of the web apps running on Azure. In this step, I created an App Service plan with the B1 pricing tier on a Linux server

--is-linux: Specifies that this is a Linux-based service plan.

Create an Azure Web App The Web App is the actual hosting service for the application. Here, I created a Python 3.9 Web App within the resource group and plan

--runtime "Python|3.9": Specifies the Python version for the app

Initialize Git and Commit Code
Once the Azure resources were set up, I initialized a Git repository in my local project folder, added all the files, and made an initial commit
Configure Local Git Deployment to Azure
Azure App Service allows you to configure local Git deployment. This step sets up the connection between my local Git repository and Azure Web App

After running this command, Azure provided a Git Remote URL that I needed to use to push my local code to the Azure App Service

Add Azure Remote to Git Using the Git URL provided in the previous step, I added the Azure remote to my local Git configuration

Get Username and Password from Azure Portal
To push the code to Azure, I needed the username and password for the Azure Git repository:
I went to the Azure Portal and navigated to my App Service (monitoring_app).
From there, I selected the Deployment Center in the left-hand menu.
Under the User Credentials section, I found the Git Username (which
- is usually the name of your app) and generated/reset the Git Password.
- Username: Typically, it’s the name of your app (e.g., @monitoring_app).
- Password: Generated in the Deployment Center.
Push Code to Azure Remote
With the username and password in hand, I was able to push my local code to the Azure Web App by using "git push azure"

Upon pushing, I was prompted to enter the username and password that I retrieved from the Azure portal. After a successful push, Azure automatically deployed the code

Verify the Deployment After the deployment was successful, I visited my web app's URL to ensure it was running

The application was live, and the CPU, memory, and disk usage metrics were accessible via the respective endpoints:

/metrics/cpu
/metrics/memory
/metrics/disk

Author
This project was developed by Uyiosa Praise Oboite

GitHub Repository
You can find the source code for this project here: Git Repository

Building Devopsfetch for Server Information Retrieval and Monitoring

Uyi Oboite — Wed, 24 Jul 2024 19:44:07 +0000

Introduction

Devopsfetch is a Bash script that provides detailed information about system components, including active ports, Docker containers, Nginx configurations, user logins, and system activities. The script is used directly in the terminal, offering command-line access to monitor and retrieve system information, making it an essential tool for system administrators and DevOps engineers.

Creating the Script

Navigate to Your Project Directory:
First, you need to navigate to the directory where you want to create your script. You can do this using the cd command in the terminal.
Create the Script File:
Use the touch command to create an empty file. This command will simply create the file without opening it for editing
Edit the File:
Open the file with a text editor of your choice, such as nano, vim, or any other editor. Using vim editor in this case can be seen below
Write the Script:
Copy and paste the script content into the editor
Save and Exit the Editor:
If you’re using vim

Enter Insert Mode:
Press i to enter insert mode, where you can start typing or paste
your script content.
Paste or Write the Script:
Paste or write your script content while in insert mode.
Save and Exit:
After entering the script content, follow these steps to save and
exit:
Press Esc to exit insert mode.
Type :wq and press Enter.
The :wq command writes (saves) the file and then quits vim.
If you only want to save the file and not exit vim, use :w instead.
To quit without saving, use :q!

Click this link for the content of the devopsfetch script

Sample Information Retrieval:

Display all active ports and services (-p or --port)
Provide detailed information about a specific port (-p)
List all Docker images and containers (-d or --docker)
Provide detailed information about a specific container
(-d container_name)
Display all Nginx domains and their ports (-n or --nginx)
Provide detailed configuration information for a specific domain
(-n domain)
List all users and their last login times (-u or --users)
Provide detailed information about a specific user (-u username)
Display activities within a specified time range (-t or --time)

Automating Dependency Installation and System Monitoring

The install_dependencies.sh Script

This script is designed to automate the installation and setup of essential system dependencies for a server. This script ensures that Docker, Nginx, and log-rotate are installed and properly configured to start on system boot

Script Overview

Update and Install Dependencies
Updates the package lists for the Ubuntu system.
Installs Docker, Nginx, and logrotate if they are not already installed
Enable and Start Services
Enables Docker and Nginx services to start automatically on system boot.
Starts Docker and Nginx services immediately after installation.

Script Breakdown

Update and Install Dependencies

Updates the package lists for the Ubuntu system. This command updates the local package index with the latest changes made in the repositories. It ensures that you install the latest versions of the software packages

Installing Docker, Nginx, and Logrotate

docker.io: The package for Docker, which is used to manage containers.
nginx: The package for Nginx, which is a web server and reverse proxy server.
logrotate: The package for managing and rotating log files.
The -y flag automatically answers "yes" to any prompts during installation

Enabling and Starting Docker Service

systemctl enable docker: Configures Docker to start automatically when the system boots.
systemctl start docker: Starts the Docker service immediately.

Enabling and Starting Nginx Service
Ensuring Log-rotate is Installed
Installs log-rotate to manage and rotate log files, ensuring that logs do not consume excessive disk space

Usage

Make the Script Executable
Before running the script, ensure it has executable permissions
Run the Script
Execute the script to perform the installation and setup

install_dependencies script

The devopsfetch_monitor.sh Script

A devopsfetch_monitor.sh script is designed to continuously monitor and log various system metrics and configurations. It collects information such as system details, CPU and memory usage, disk usage, active users, recent logins, open ports, and Nginx domain information. The collected data is then logged into a specified log file

Setup

Location of the Script:
The script is located at
/home/praisephs/server_monitoring/devopsfetch_monitor.sh
Log File Configuration:
The log file where the monitoring data is stored is specified in the script
LOG_FILE="/home/praisephs/server_monitoring/devopsfetch_logs/devopsfetch.log"

How It Works

Initialization:

The script starts by defining the log file location and the format for timestamps:
It logs the start of the monitoring process:

Continuous Monitoring Loop:

The script enters an infinite loop, where it performs the following actions at each iteration:

System Information Collection: It logs a timestamp and then collects various system metrics:

System Information: General system information is collected using the uname -a command

CPU and Memory Usage: Top processes by CPU and memory usage are listed using the top command

Disk Usage: Disk space usage for all mounted filesystems is collected using the df -h command

Memory Status: Memory usage and availability are logged using the free -h command

Active Users: Currently logged-in users are listed using the who command

Recent User Logins: Recent login attempts are logged using the
last -n 5 command

Open Ports: A list of open network ports is generated using the ss -tuln command

Nginx Domain Information: The script extracts domain information from Nginx configuration files located in /etc/nginx/sites-available/

Logging the Data: All collected data is appended to the specified log file in a well-structured format
Delay Between Iterations: The script waits for an hour before starting the next data collection cycle

Link to devopsfetch_monitor,sh

Logging the Data: All collected data is appended to the specified log file in a well-structured format

Log Rotation
To manage the size of the log file and ensure the system does not run out of disk space, a manual log rotation script manual_log_rotate.sh is used.

Location of the Log Rotation Script
The log rotation script is located at:
/home/praisephs/server_monitoring/manual_log_rotate.sh
How It Works
The log rotation script checks the size of the log file and rotates it if it exceeds a specified size
Log File and Maximum Size Configuration

Log Size Check and Rotation The script checks if the log file size exceeds MAX_SIZE. If it does, the log file is renamed with a timestamp, and a new log file is created

The log rotation script should is scheduled to run periodically using a cron job to ensure the log file does not grow too large

In simple terms, a cron job is a scheduled task that runs automatically at specific intervals on a Unix-based system (like Linux). You can think of it as a timer that triggers a particular command or script to execute at regular times, such as daily, weekly, or every hour

Usage
Starting the Monitoring Script
To start the monitoring, run the script using:
sudo /home/praisephs/server_monitoring/devopsfetch_monitor.sh

NB: Ensure that the script has execute permissions and is run with appropriate permissions to access all required system information

Starting the Log Rotation Script
The log rotation script can be run manually or scheduled to run periodically:
sudo /home/praisephs/server_monitoring/manual_log_rotate.sh
Log File Access
The log file containing the monitoring data is located at:
/home/praisephs/server_monitoring/devopsfetch_logs/devopsfetch.log

Users can access and review this log file to analyze system metrics and activity

To print the status of system monitoring use:
cat /home/praisephs/server_monitoring/devopsfetch_logs/devopsfetch.log

Confirmation of System Monitoring

Seeing both devopsfetch.log and devopsfetch.log.1.gz in devopsfetch_logs directory indicates that the system monitoring is working and data archiving is in place

devopsfetch.log: This is the current active log file where new log entries are appended
devopsfetch.log.1.gz: This is a compressed archive of the previous log file. The .gz extension indicates that it's been compressed using gzip

The presence of the archived log file (devopsfetch.log.1.gz) shows that log rotation is working, and old log data is being archived properly to save space and manage log files effectively.

Managing Users in PraisePHS Microsystems Ltd with a Bash Script

Uyi Oboite — Thu, 04 Jul 2024 15:49:45 +0000

In any corporate environment, managing users efficiently and securely is paramount. PraisePHS Microsystems Ltd. employs a systematic approach to user management using a Bash script. This article will explain how the provided Bash script functions, ensuring smooth and secure user creation and management.

Overview
The script takes a file containing user and group information as input, creates users, assigns them to specified groups, sets passwords, and logs the process. The users.txt file, for example, provides the necessary user and group details in a semicolon-separated format.

Bash Script Breakdown
Here's a step-by-step explanation of the script:

The script starts by defining the necessary files: the input file containing user information, the log file for logging actions, and the password file for storing generated passwords.
This function generates a random password using OpenSSL's rand function, ensuring a strong and unique password for each user.
This section ensures the existence and correct permissions of the log and password files. If these files or directories do not exist, the script creates them and sets appropriate permissions to ensure security

The script reads each line of the input file, removes any carriage returns, trims whitespace, and skips empty lines to ensure clean data processing.

User Existence Check: The script checks if a user already exists. If they do, it logs this information.
User Creation: If the user does not exist, the script generates a password, creates the user with a home directory, sets the password, and logs these actions.
Group Management: The script adds the user to specified groups. If a group does not exist, it creates the group before adding the user.
Permissions and Ownership: Finally, the script sets the permissions and ownership for the user's home directory to ensure security.

Example Input File: users.txt
The users.txt file contains user information in the format username; group1,group2

For more information about the HNG internship, visit the HNG Internship page

If you are looking to hire talented interns, check out the HNG Hire page