DEV Community: Paschal Ogu

How I Self-Host Metabase & Why Your Team Should Too

Paschal Ogu — Tue, 24 Feb 2026 22:26:29 +0000

If you have not yet explored Metabase, this is for you.

I have had this piece sitting in my drafts for a long time because I kept asking myself a simple question: Do businesses really need yet another tool?

The answer, for me, ended up being yes.

Metabase is one of those rare tools that feels equally friendly to non-technical teammates and powerful enough for someone who wants to write SQL, model data, and build dashboards that actually get used.

What is Metabase?

Metabase is an open-source business intelligence tool that helps people explore, visualize, and understand data. If you are working in a startup, it usually shows up in moments like these:

Ops wants a daily view of signups, churn, or cashflow.
Sales wants a clean dashboard they can check without waiting on engineering.
Product wants quick answers without spinning up a full analytics pipeline.

Image below shows sample dashboard built with metabase:

Why I think this matters — especially for startups

Most startups struggle because their data is scattered, hard to query, and only a few people can make sense of it. Metabase helps by making data visible to the wider team, reducing the time it takes to answer basic questions, and building a habit of checking numbers before making decisions.

A few Metabase features I like

Here are some of the highlights, with links to the official Metabase docs:

Set up quickly: Set up in five minutes — Unlike most BI tools that require lengthy onboarding or dedicated IT support, Metabase gets you from zero to exploring data in minutes with a straightforward guided setup.
Self-serve analytics: Let anyone ask questions — The question builder lets non-technical teammates pull their own insights without writing a single line of SQL, reducing the bottleneck on data and engineering teams.
Power user mode: SQL editor — For those who prefer working directly with the database, the built-in SQL editor gives full flexibility without ever leaving the tool.
Beautiful dashboards: Dashboards — Metabase makes it easy to combine charts, metrics, and tables into clean, shareable dashboards that look good without any design effort.
Automated sharing: Dashboard subscriptions — Schedule dashboards to be delivered by email or Slack on a recurring basis, keeping stakeholders informed without anyone manually sending reports.
Proactive monitoring: Alerts — Get notified when a metric crosses a threshold so you catch problems or opportunities as they happen, not in a weekly review.'

Cloud vs self-hosted

Metabase can be used in two main ways:

Cloud — You pay Metabase to host it for you.
Self-hosted — You run it on your own server.

In this post I focus on self-hosting because you keep full control of your data, you can place it close to your database, and it is a great option for teams already running services on a VPS or AWS.

Self-hosting Metabase with Docker

What you will need

A laptop or VM with Docker installed
An SQL client (MySQL Workbench or DbGate works fine)

What we are going to do

Run a MySQL database in Docker
Load sample data into MySQL
Run Metabase in Docker
Connect Metabase to MySQL
Build your first question and dashboard

Step 1: Run MySQL in Docker

docker run \
  --name test-mysql \
  -v my-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=strong_password \
  -e MYSQL_USER=customuser \
  -e MYSQL_PASSWORD=custompassword1 \
  -e MYSQL_DATABASE=mydatabase \
  -p 3306:3306 \
  -d mysql

Here is what each flag does:

--name test-mysql — names the container so you can reference it later
-v my-mysql-data:/var/lib/mysql — creates a Docker volume so data persists if the container restarts
-e MYSQL_ROOT_PASSWORD — sets the root password
-e MYSQL_USER / -e MYSQL_PASSWORD — creates a non-root user
-e MYSQL_DATABASE=mydatabase — creates a database on first start
-p 3306:3306 — exposes MySQL on port 3306
-d mysql — runs the official MySQL image in detached mode

To confirm the container started correctly:

docker logs test-mysql

Step 2: Download and import sample data

Download the MySQL sample database from mysqltutorial.org, unzip it, and import the SQL dump using MySQL Workbench or DbGate. You should be able to preview all the tables after the import completes.

Step 3: Run Metabase

docker run -d -p 3000:3000 --name metabase metabase/metabase

Give it a minute or two to boot, then open your browser at http://localhost:3000 or http://your-ip-address:3000. Follow the setup wizard — choose your language and create your admin account.

Step 4: Connect Metabase to MySQL

Metabase is able to connect to host of databases below:

When Metabase prompts for database connection details, use:

Field	Value
Port	`3306`
Database name	`mydatabase`
Username	`customuser`
Password	the password you set above

Step 5: Build something small

Once the connection works, try this:

Ask a simple question — for example, total payment per month.
Save it.
Add it to a new dashboard.
Share the dashboard link with your team.
Create notification to alert your team of important events.

This is the moment Metabase starts paying for itself.

Closing thoughts

I like Metabase because it is practical. It gets a team from "we have data" to "we can actually use it" without a heavy setup or a dedicated data engineer.

Do you need help self-hosting Metabase for your organization? Feel free to reach out to me on LinkedIn and on Twitter @Paschal_ik

If you found this useful, you can buy me a coffee — I'd always appreciate you.

Growing in a Job you Love: Simple Yet Powerful Strategies That Work

Paschal Ogu — Thu, 23 Jan 2025 19:51:22 +0000

Two years ago, I attended a session by Michael Madu where he delivered a powerful session that stuck with me. The nuggets he shared shaped my approach to work at Anchor ever since. I came to realise that it’s not just about having the right skills—it’s also about aligning your efforts with what truly matters to the business.

Below are tested strategies you can incorporate to remain relevant and grow in any job you choose:

1.) Know and Care About the Business

Take the time to understand the business: goals, challenges, and the value delivered to customers. When you genuinely care about the business, it shows. You’ll make better decisions, prioritize effectively, and demonstrate that you’re not just a number in the team.
Don't be shy to ask questions about the business model. Pay attention to industry trends and show that you’re invested in more than just your role. From a personal standpoint, it is rare to retain what you don't care about.

2.) Link Your Work to the Company's Bottom Line

Every business cares about two things: making money and saving money. The more directly your work ties into these goals, the more relevant you are to the organization.

Revenue Generation: Are you helping attract, retain, or satisfy paying customers?
Cost Savings: Are you improving processes, reducing inefficiencies, or cutting unnecessary expenses? Think about how your role fits into these two boxes.

3.) Show Up and Own Something

When you’re the go-to person for something important, your value increases. Being reliability and accountability sets you apart. Even if it is a process or problem you identified that need to be solved, take full ownership and deliver results. Ownership isn’t just about doing what was assigned; it’s about identifying opportunities for improvement, solving problems proactively, and taking initiatives.

Bonus Point:

4.) Communicate your impact - Show Working

Use metrics and tangible results to highlight how your work contributes to the company’s financial health. Don’t just do the work—show the value of the work.

If you found this article helpful, you can support me here: Buy Me a Coffee

Do you have any approach to staying relevant and growing in your job? You can share them in the comments! 💡

What developers really want

Paschal Ogu — Sat, 21 Dec 2024 20:24:33 +0000

I had the opportunity to assist over 200+ businesses and developers build and scale financial solutions in 2024.

Through this, I got valuable insights on what developers are looking for when selecting an API provider to power their innovations.

Summarised below are five key factors consistently come up in discussions with developers:

1.) Security 🔐 : Developers prioritize the protection of their data and that of their users. When events are sent across systems, developers expect these events to be encrypted and protected against interception or tampering by bad actors. Security is simply non-negotiable!

2.) Reliability 📈: Uninterrupted service is a top priority. APIs must be fast, reliable, and have strong high uptime values. Providers who fulfil their promises are highly valued by developers.

3.) Consistent API Structure : A uniform API structure facilitates integration. Developers value predictable API formats and user-friendly error messages.

4.) Comprehensive & Updated Documentation 📝: The quality of documentation significantly influences developers' experience. In-depth documentation including use cases, examples, step-by-step instructions, and easily searchable references significantly enhance developer satisfaction. Great docs = Great experience!

5.) Fast Support Response Time 🧑‍💻: When developers hit a roadblock, they need answers, and they need it fast ⚡️. Support must be great for developers to keep coming back.

Which of these factors do you believe holds the most significance for developers?

If you found this article helpful, you can support me here: Buy Me a Coffee

Let me know your thoughts in the comments!👇 Also, feel free to connect with me on LinkedIn at Paschal Ogu and on X (formerly Twitter) @Paschal_Ik

PS:
If you are developing a solution tailored for developers, feel free to drop a DM. Let's collaborate.

I Passed Google Associate Cloud Engineer Certification Exam in One Sitting 🕺🏻🥳

Paschal Ogu — Sun, 28 Jul 2024 15:21:05 +0000

The reliability of Google's email service, Gmail, sharpened my keen interest in Google's Site Reliability Engineering (SRE) culture. I was intrigued by the secrets behind its remarkable availability, so I went deep into understanding their insfrastrture.

Gmail is a service I use daily, and its exceptional reliability inspired me to learn more. I went on a journey to understand how Google configures, deploys, and manages cloud solutions that power Gmail. This curiosity ultimately led me to certification. Safe to say my curiosity got me certified.

I validated my experience in cloud technology by earning the Associate Google Cloud Engineer certification and badge. This achievement serves to prove my ability to configure, deploy, and manage cloud solutions on the Google Cloud Platform (GCP).

In this post, I will be detailing the key resources I used to adequately prepare for and pass this exam in one sitting and explain why this certification is important to me.

👉 Verify my credentials here👈

How I Prepared: Journey, Duration and Cost

As you may already guess, cloud concepts are not new to me. I have years of experience with Amazon Web Services (AWS), Microsoft Azure Cloud, Oracle Cloud, DigitalOcean and other cloud providers. To sit for this examination, all I needed was consolidate the knowledge to Google Cloud concepts.

The Google cloud certification journey started with my interest to join the Google Cloud Innovators. The program looks for practitioners who are passionate, driven, and ready to push boundaries. I got an email invite to join the Get Certified program. This program lasted for 10 weeks and was packed with hands-on labs, video and text based resources.

The Associate Cloud Engineer certification exam costs $125 at the time of publishing this post. However, as a benefit of being in the Get Certified program, you get voucher to sit for one exam from Google.

Resources Used

Google Cloud Free Credit: I signed up for the Google Cloud free trial. The GCP free trial was an excellent resource for gaining hands-on experience. I completed several labs and exercises, which reinforced my theoretical knowledge.
Cloud Skills Boost (formerly Qwiklabs): This Cloud Engineer Learning Path provided free access to labs, videos and texts to guide my preparation.
Udemy & YouTube Courses:
- "Google Cloud Associate Cloud Engineer certification" by Ranga Karanam. I highly recommend this course.
- There are also several free YouTube courses available, such as this one by freeCodeCamp.org.
Practice Exams:
- Google provides an official preparation guide and review questions here.
- However, I highly recommend the practice exam course on Udemy

The Personal Impact of My Certification

Adding this certification to my profile enhances my professional credibility. It serves as an official acknowledgment of my expertise in Google Cloud and cloud technologies as a whole. I am certain it would open doors to opportunities and collaborations within the cloud space.

On a personal level, passing this GCP ACE exam is a proud accomplishment. It reflects my dedication, hard work, and ability to achieve my goals. This sense of personal achievement motivates me to continue learning and pursuing further professional development opportunities. (I would get to back my proposals with official certification from Google) 🤠.

What This Means for You

With my Google Cloud certification, I'm well-equipped to handle cloud operations, host applications, manage infrastructure and monitor services in a compliant and secure manner.

If you're interested in leveraging cloud technologies for your business, feel free to reach out. Let's explore how we can drive your business forward!

LinkedIn: Paschal Ogu
Follow on X (twitter): x.com/@paschal_ik

What's Next

My plan is to continue building and deploying in the cloud. I am also considering pursuing the Google Cloud Professional Certification or the AWS Cloud Solution certification.

💡 This article was first published at blog.paschalogu.com. If you found it useful, follow me on Twitter, and on LinkedIn. Also subscribe to my YouTube Channel: PaschalBuilds.

Simplified Virtual Development Environment on the Browser: GitHub Codespace

Paschal Ogu — Wed, 19 Jun 2024 21:35:39 +0000

Starting my cloud journey, one of the biggest challenges I faced was finding a place to practice Linux commands. GitHub Codespace has completely solved this problem.

As a seasoned professional, imagine being able to take your entire local development environment with you, minus the hassle of carrying your computer. GitHub Codespace offers exactly that. Codespace is a cloud-based service that allows you to create and run your projects directly from your browser. No need to set up your projects on your local machine — everything you need is hosted online and accessible from any device through the web.

Executive Summary

This article aims to introduce and simplify GitHub Codespace: a cloud development environment for developers. It covers the prerequisites, pricing, steps to launch and set up a Codespace, including installing essential tools like Terraform, AWS CLI, and Ansible. The guide also details how to push code changes to GitHub and manage Codespace efficiently.

What is GitHub Codespace?

GitHub codespace is a remote compute with a text editor (Visual Studio Code) attached to it that runs on the cloud, where you can set up a development environment. This means that you can install all your project dependencies and run from the browser. It automatically sets up all the necessary components for your project, including the source code, runtime, compiler, debugger, editor, custom configuration files, relevant editor extensions, and additional features.

With codespace, individuals can get up to 60 hours of free compute per month, The best part is, it has vim and nano preinstalled. 🤠

In this guide, I’ll walk you through the process of installing Terraform and AWS CLI within a codespace, enabling you to manage your infrastructure as code directly from the cloud on the go.

Pre-requisite:

To follow along, you simply need to have a Github account. You can click here to sign-up.

Steps to launch GitHub Codespace

i.) Create a GitHub Repository

Log into Github.com
Click on “New”, at the top left page of the screen to add a new repository.

Give you the new a ay name, and select the button to Add a README file. Then click on “Create”

ii.) Create Codespace for the Repository

Once the repository has been created, we can add a codespace using the following steps:

Navigate to the newly created repository and click on “Code”.
Select "Codespaces" and then click on “Create codespace on main”.

This process will generate a virtual development environment on the main branch of the repository, facilitating seamless coding and collaboration."

A couple of things happen when you create your development environment:

VM and storage are assigned to your codespace.
Container is created and your repository is cloned.
You can connect to the codespace.
Codespace continues with post-creation setup.

This will open a text editor (visual studio code) on a new browser window, we you can start your development.

Set-up the Codespace

Welcome to the exciting part where you get to set up your virtual environment to mirror your local development setup. This virtual environment will allow you to write, compile, debug, and test your code just like you would on your local machine.

In the below steps, we will setup and install terraform, AWS CLI, and Ansible on or virtual environment.

Install Terraform, AWS CLI and Ansible

i.) Make a File

Open your terminal within the virtual code environment and use the following command to make a new file nano setup_tools.sh . This command above will open up the nano editor on your terminal.

nano setup_tools.sh

Tip: If your terminal is not open by default, you can open this by using the hamburger button at the top right, select Terminal and New Terminal.

ii.) Add SetUp Script to the File

Copy the bash script below into the terraform installation file created above.

#!/bin/bash

# Update package list
sudo apt-get update

# Install dependencies
sudo apt-get install -y gnupg software-properties-common curl

# Add HashiCorp GPG key
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -

# Add Terraform repository
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"

# Update package list again
sudo apt-get update

# Install Terraform
sudo apt-get install -y terraform

# Install AWS CLI
sudo apt-get update
sudo apt-get install -y awscli

# Install Ansible
sudo apt-get update
sudo apt-get install -y software-properties-common
sudo add-apt-repository --yes --update ppa:ansible/ansible
sudo apt-get install -y ansible

# Verify installation
terraform --version

# Verify installation
aws --version

# Verify Ansible installation
ansible --version

To save and exit the editor, press Ctrl + O, then Enter to confirm the file name, and finally Ctrl + X to exit.

Now, file setup is ready, and you can proceed with running the script to install Terraform, AWS CLI, and Ansible on your virtual environment.

iii.) Execute Script

Run the installation script to install terraform and print the version of terraform installed.

bash setup_tools.sh

This will execute all the necessary steps to install Terraform in your GitHub codespace environment.

Push your Changes to GitHub

Follow these steps to add your changes, commit them with a message, and push them to your GitHub repository:

i.) Stage the File for Commit

Use the git add command to stage the setup_tools.sh file. This prepares the file for committing.

git add setup_tools.sh

ii.) Commit the Changes

Next, commit the staged file with a descriptive message. This message should give an idea of what changes or additions you made.

git commit -m "Add setup script"

iii.) Push the Changes

Finally, push your commit to your GitHub repository. This uploads your changes to GitHub.

git push

Codespace is intelligent to push this change to your GitHub repository.

To Stop and Exit GitHub Codespace

i.) List Your Codespaces

On the your terminal, use the following command to list all your active Codespaces. This will help you find the name or ID of the Codespace you want to stop.

gh codespace list

ii.) Stop the Codespace

Once you've identified the codespace you want to stop, use the following command, replacing <codespace_name_or_id> with the actual name or ID of your Codespace:

gh codespace stop -c <codespace_name_or_id>

Here is a sample command:

gh codespace stop -c miniature-xylophone-wxq5v5pxx5gf57wp

Running the above command will kill the session and effectively stop and exit your GitHub Codespace, ensuring that you are not incurring unnecessary usage or costs.

Once you have run the command above, you can safely close the browser.

Final Thoughts

GitHub Codespace is a game changer, providing a simplified, cloud-based development environment accessible directly from the browser. By following the outlined steps in this guide, developers and cloud enthusiasts can quickly set up and configure their workspace, install necessary tools, and seamlessly push changes to GitHub.

How I Deployed my Website as a Docker Container

Paschal Ogu — Fri, 29 Sep 2023 21:17:00 +0000

One of the greatest nightmares of developers is the “It's not working on my machine” problem. I struggled to run my website locally on different machines too. Shout out to Brittany Mitchell for giving me the idea to containerize my website. Containerization allowed me to build my website and run it consistently across different environments and machines. Docker is the tool for achieving this containerization.

What is Docker?

Docker is an open-source platform for developing, shipping, and running applications. It is a technology that allows you to incorporate and store your code and its dependencies into a neat little package called an image.

Dockerfile, Docker Image, and Docker Container

Dockerfile:

A Dockerfile is a text file containing a collection of commands or procedures. Consider this file as a script that defines how our container image will be built.

Docker Image:

A docker image is a packaged, runnable instance of an application or environment. It contains everything needed to run a piece of software (or website in our case), including the code, a runtime, libraries, environment variables, and configuration files. A docker image is read-only template for creating containers.

Docker Container:

A docker container is a lightweight, stand-alone, executable package of software that includes everything needed to run the software. Containers isolate applications from each other and the underlying infrastructure while providing an added layer of protection for the application. Containerization solves the problem related to application deployment, and scalability. It helps promote consistency and efficiency in software development and operations.

Here is how I containerized my website

As a prerequisite, ensure that you have docker installed locally on your machine. Install Docker Engine

The code for my website is hosted on GitHub. To follow along, fork and clone this repository and change directory into it by running the commands below:

git clone https://github.com/paschalogu/personal-website.git
cd personal-website

Step 1: Build the Docker image

Add a Dockerfile

I created a new file named Dockerfile by running the command touch Dockerfile in the root of my website directory and added these lines of code below inside the Dockerfile:

FROM nginx:alpine

COPY . /usr/share/nginx/html

EXPOSE 80

The FROM nginx:alpine line tells Docker to create a Docker image based on the Nginx web server with Alpine Linux. The COPY . /usr/share/nginx/html line will copy the website content from the directory we are in into the image being built. This means that our website code will replace the default Nginx web server content. EXPOSE 80 specifies that the container should be capable of serving HTTP traffic on port 80.

Build Image

Then I built the image by running the line of code below:

docker build -t personal-website:v1 .

docker build command tells docker to build our website as an image based on the instructions provided in a Dockerfile above. The -t personal-website:v1 tells docker to tag the image personal-website:v1. v1 signifies that this is version 1. The period (.) tells Docker to look for the Dockerfile in the current directory and use the files and directories in this location during the build process.

Running the command docker images shows this image I just built:

Step 2: Push to Docker Registry

I logged in to Docker Hub Container Image Library and created a new repository. I named it personal-website and gave it a short description (description is optional).

Then I ran the docker push command below to push the image I built in the previous step, but it failed with the error below 😞.

docker push paschalogu/personal-website:v1

The push refers to repository [[docker.io/paschalogu/personal-website](http://docker.io/paschalogu/personal-website)]
An image does not exist locally with the tag: paschalogu/personal-website

Why did it fail? The push command was looking for an image named paschalogu/personal-website:v1, but didn't find one.

To fix this, I ran the docker tag command to tag my image and then re-ran the docker push command to push to my docker repository.

docker tag personal-website:v1 paschalogu/personal-website:v1

docker push paschalogu/personal-website:v1

Step 3: Test Configuration

Opened my browser and navigated to the website https://labs.play-with-docker.com/

Selected Login and then chose docker from the drop-down list. Then, I sign in with my Docker Hub account and clicked the Start button.

I clicked on ADD NEW INSTANCE option on the left sidebar. After a few seconds, a terminal window opened up in my browser.

In the terminal, I started my freshly pushed wevsite.

docker pull paschalogu/personal-website:v1

docker run -dp 80:80 paschalogu/personal-website:v1

Will you be running your applications and websites as a docker container? Let me know in the comments. Feel free to connect with me on LinkedIn at https://www.linkedin.com/in/paschal-ogu/ and on Twitter @Paschal_Ik

If you found this article helpful, you can support me here: Buy Me a Coffee

References:

https://www.aquasec.com/cloud-native-academy/docker-container/

https://docs.docker.com/get-started/04_sharing_app/.

Project: Set up EKS, ECR, and MySQL Database using Terraform in AWS

Paschal Ogu — Sat, 02 Sep 2023 10:04:18 +0000

Objectives:

To use infrastructure-as-code tools (Terraform):

Set up Elastic Kubernetes Service (EKS) cluster, Virtual private Cloud (VPC), subnets, and other required resources.
Set up a private Docker registry to store the application's Docker images.
Setup MySQL Database.

The repository referenced throughout this project is hosted on my github: https://github.com/paschalogu/Terraform

Infrastructure Architecture Diagram

Figure 1: Infrastructure diagram of the setup

Client device used to prepare the infrastructure as code. It should have git, terraform and AWS CLI installed.
GitHub: Source Code Management GitHub used for code versioning. With git pull/git push, files are kept in sync with the remote server.
Terraform: The infrastructure-as-code tool used to codify and provision the infrastructure on cloud.
AWS Cloud, where the infrastructure resources are provisioned.

Step 0: Getting Started

Prerequisites:
To reproduce this set-up:

Familiarity with Linux, Git and GitHub, infrastructure-as-code and DevOps has been assumed.
Ubuntu Linux 20.04 Focal Fossa LTS distribution was used for all the activities in the task.
An AWS account with appropriate permissions to create resources like EKS, VPC, subnets, ECR, and RDS (MySQL) is required. Visit this link to create an AWS account if you don't already have an account.

Considerations:

Availability: For High availability and fault tolerance, instances have been replicated on different availability zones (us-east-1a, us-east-1b, us-east-1c) within the same region.
Security: Principle of Least Privilege was considered when assigning policy to IAM role for the cluster.
Security: Public access to the MySQL database has been disabled.

Step 1: Confirm Terraform is Installed Locally

The command to install Terraform may be slightly different, depending on your local operating system. Refer to the terraform installation documentation for system-specific requirements: Install Terraform.
Below is a command to install Terraform classic on an Ubuntu Linux machine.

sudo apt update && sudo apt upgrade -y
sudo snap install terraform --classic

To confirm the version of Terraform installed, run the command: terraform --version. This command will print the version of terraform installed.

Figure 2: showing version of terraform installed

Step 2: Install and Configure AWS CLI to Authenticate to AWS.

Download and install the AWS CLI based on your operating system. Refer to this AWS documentation for device/operating system specific instruction: Install or update AWS CLI.

Below is a command to install it on Linux, distribution.

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

To confirm the version of terraform installed, run the command: aws --version. This command will print the version of AWS CLI that is installed.

aws --version

Figure 3: showing version of aws-cli installed

Optionally, you can run this command to remove the installation files:

rm -r aws awscliv2.zip

Set Up AWS Environment Variables

Set up AWS environment variables to help Terraform automatically pick up your AWS credentials.

Get your access keys and secret keys from AWS: follow this documentation for the detailed steps: AWS Account and Access Keys
Run the command on your terminal: aws configure.

aws configure

Set the following environment variables with your AWS credentials:

AWS_ACCESS_KEY_ID: < AWS_Access_Key_ID >
AWS_SECRET_ACCESS_KEY: < AWS_Secret_Access_Key >
AWS_DEFAULT_REGION: < Preferred_AWS_region (e.g., us-east-1) >
Default output format: json

Run the following command to verify that your AWS CLI is configured correctly:

aws sts get-caller-identity

You should see information about the AWS account that your credentials are associated with.

Step 3: Create your Terraform Configuration Files:

Option 1: Pull the repository from GitHub

Clone the Terraform repository from GitHub to your client device and change directory cd into this repository:

git clone https://github.com/paschalogu/Terraform.git
cd Terraform

Option 2: Create your own terraform configuration files

Make a Repository on your local device to hold Terraform codes, and change directory to this newly created repository.

mkdir Terraform && cd Terraform

The mkdir command creates the directory, and the cd command changes the working directory to the newly created "Terraform" directory.

Create main.tf for the main Terraform configuration, variables.tf to define variables (helpful for managing settings), and outputs.tf to define outputs (display useful information after running terraform apply).

touch main.tf variables.tf outputs.tf

The command above creates the three files at ones.

Write your Terraform code in the Appropriate Files.
Run the command nano main.tf and paste the code from main.tf inside:
Repeat same steps for variables.tf and outputs.tf and paste the code from variables.tf and outputs.tf respectively.

This is the structure of the directory after files have been created.

Figure 4: Showing the structure of the Terraform Directory

Resources to be created:

Virtual Private Cloud (VPC): The Virtual Private Cloud will be created to isolate virtual networks within the AWS cloud infrastructure, providing control over network settings, IP address ranges, and subnets securely.
Subnets: Three subnets will be created within 3 availability zones. This multi-AZ architecture is considered and designed to provide redundancy and high availability.
IAM Role: Identity and Access Management (IAM) role that has the necessary permissions for managing the cluster will be created. This IAM role will be used by the EKS cluster.
IAM Role Policy Attachment: A resource to attachment the AmazonEKSClusterPolicy to the IAM role created for the EKS cluster.
Elastic Kubernetes Service (EKS) cluster: AWS EKS cluster will be created and associated with the IAM role created above.
Elastic Container Registry (ECR): An Elastic Container Registry in which you to store Application Docker images will be created.
MySQL database Instance: An RDS MySQL instance with the specified configurations like identifier, engine, instance class, allocated storage, username, password, etc.

Step 4: Initialize, Plan, and Apply Terraform Configuration in your Project Directory:

To initialize the terraform project, run the command:

terraform init

To review the list of changes that will be applied during creation, run the command below:

terraform plan

Apply Terraform configuration to create AWS resources:

terraform apply

Terraform will display the changes to be made to AWS cloud infrastructure. Type yes and press Enter to confirm and apply the changes. To see the state of the infrastructure, run the command below:

terraform state list

Figure 5: Showing the terraform state command

Alternatively, you can use AWS CLI or the AWS Management Console to verify that the resources were created as expected.

Step 5: Pushing the code to GitHub

Create a new repository on GitHub and push the Terraform repository from the command line.

Initialize the repository for git to track changes in the repository.On your project directory, run the below command to initialize git:

git init

Create a .gitignore file by running the command nano .gitignore.
Input the files you don't want to commit to gitHub in this .gitignore file. This includes variable files and terraform state files. Any file added here will not be pushed to GitHub. Add below files to the .gitignore file:

.git/
.terraform/
*.tfvars
terraform.tfstate
terraform.tfstate.backup
.terraform.lock.hcl
variables.tf

Proceed to add, commit, and push the code to Github.

git add .
git commit -m "Commit Message"
git branch -M main
git remote add origin https://github.com/<github_username>/<github_repo>.git
git push -u origin main

Step 6: Deletion of Resources

To destroy, delete and clean up everything, run the destroy command below and type yes when prompted:

terraform destroy

If you found this article helpful, you can support me here: Buy Me a Coffee

GitHub Actions in Automation: Display Latest Blog Posts and Badges on your GitHub Profile

Paschal Ogu — Tue, 25 Jul 2023 08:11:17 +0000

Whenever I publish a blog post here on Dev Community, or achieve a new badge from Credly, I have to manually update my GitHub profile to display these updates. It's not the most exciting task and can be a drain on productivity.

There has to be a way to automate the boring stuffs, right? Isn’t that what developers do?

The answer is yes! This is where GitHub Actions comes in.

In this blog post, we will explore GitHub Actions automation solution to eliminate this repetitive process.

What is GitHub Actions?
Steps to auto-update Dev.to Blog Posts on GitHub Profile
Steps to auto-update Credly Badges on GitHub
Conclusion

What is GitHub Actions?

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline.

GitHub Actions helps you automate processes in your GitHub repository using workflows. Workflows are configurable-automated processes that will run one or more jobs. Workflows are defined by a YAML file checked in to your repository and will run when triggered by an event in your repository, or they can be triggered manually, or at a defined schedule. Learn how to write GitHub Actions YAML files in the GitHub Tutorial.

Let's get into it.
The code used in this blog post can be found on my GitHub repository

Steps to auto-update Dev.to Blog Posts on GitHub Profile:

a.) Edit your special repository README file on GitHub <username>/<username>/README.md. Add the following section to your README.md file:

---
## Latest Blog Posts
<!-- BLOG-POST-LIST:START -->
<!-- BLOG-POST-LIST:END -->

b.) On this special repository, create a folder named .github and create workflows folder inside if it doesn't already exist.
c.) Create a new file named blogpost-update.yml inside this workflows directory. Copy and paste the below YAML code inside the file you just created:

name: Latest blog post workflow
on:
  schedule: # Run workflow automatically
    - cron: '0 * * * *' # Runs every hour, on the hour
  workflow_dispatch: # Run workflow manually (without waiting for the cron to be called), through the Github Actions Workflow page directly
permissions:
  contents: write # To write the generated contents to the readme

jobs:
  update-readme-with-blog:
    name: Update this repo README with latest blog posts
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: gautamkrishnar/blog-post-workflow@master
        with:
          feed_list: "https://dev.to/feed/<devto username>"

d.) Replace the feed_list URL with your own dev.to RSS feed.
e.) Save the changes and commit your code. You can either allow this workflow to run automatically, or you can manually trigger this workflow.

Here are some other popular blog sources you may want to automate:

Dev.to: https://dev.to/feed/username

Medium: https://medium.com/feed/@username

Hashnode: https://@username.hashnode.dev/rss.xml

WordPress: https://www.example.com/feed/

YouTube Channel Video: https://www.youtube.com/feeds/videos.xml?channel_id=channelId

Steps to auto-update Credly Badges on GitHub:

a.) Edit your special repository README file on GitHub //README.md.
b.) Add the following section to your README.md file:


---
## View my verified badges
<!--START_SECTION:badges-->
<!--END_SECTION:badges-->

c.) Create a GitHub workflow YAML file, badge-update.yml. Copy the below code and paste it to the new workflow YAML file you created.

name: Update Credly Badges

on:
  schedule:
    # Runs at 2am UTC
    - cron: "0 2 * * *"
  workflow_dispatch: # Run workflow manually (without waiting for the cron to be called), through the Github Actions Workflow page directly
permissions:
  contents: write # To write the generated contents to the readme

jobs:
  update-readme:
    name: Update Readme with badges
    runs-on: ubuntu-latest
    steps:
      - name: Badges - Readme
        uses: pemtajo/badge-readme@main
        with:       
          CREDLY_USER: <credly username> # optional, but default will use the same from github

d.) Replace the with your own credly username.
e.) Save this change and commit your code. You can either allow this workflow to run automatically, or you can manually trigger it.

Here is how my GitHub Profile looks after running the workflows.

Conclusion

In this blog post, we introduced GitHub Actions, defined GitHub Actions workflows, dived into the steps to auto-update Dev.To Blog Posts on GitHub Profile and steps to auto-update Credly badges on GitHub Profile. GitHub Actions is a helpful tool to automate processes and save time on repetitive tasks.

Thanks for reading. Let me know if you found this helpful. You are welcome to follow me on LinkedIn and Twitter @Paschal_ik.

How to Configure Apache web server on Linux using Ansible

Paschal Ogu — Mon, 03 Jul 2023 17:04:47 +0000

In this blog post, we will configure an Apache web server on a Linux Machine (Azure Virtual Machine) using Ansible. Apache web server is a free and open-source software that allows users to deploy their websites on the internet.

Prerequisites

Familiarity with the concept of Infrastructure-as-Code (I.a.C) is helpful, but isn't necessary.
A Linux VM: Although this action is performed on an Azure virtual machine, similar steps could be performed on any Linux distribution. You can follow this link to automate creation of virtual machines on Azure.

So, let's dive in.

What is Ansible, and why use it?

Ansible is an open-source automation tool that can be used to automate the configuration of servers and systems. It is a command-line IT automation software application that automates cloud provisioning, configuration management, application deployment, and many other IT needs. Read more about Ansible here: Get Started with Ansible.

Let's connect to our virtual machine via SSH. If you have not already created a vm, you can follow this link to automate creation of virtual machines on Microsoft Azure with Terraform. Connect to the virtual machine

ssh linuxuser@ip_address

Make a directory/folder for this Ansible project and change directory to this folder.

mkdir ansible
cd ansible

Install Ansible

Make a file for the installation of Ansible. We will call this file installations.sh.

nano installation.sh

Copy the code below into the file installation.sh Note that python is required to perform Ansible operations, hence it needs to be installed also.

#!/bin/bash

sudo apt update

sudo apt install python3-pip

pip install boto3 botocore

pip install boto

sudo apt install ansible

Run the command to change the permission of the file and make it executable.

chmod +x ./installation.sh

Run the command to install Ansible and the above requirements

./installation.sh

We can test if Ansible is properly configured by running the command below. This should print the version of Ansible installed.

ansible --version

Create an Ansible playbook

An Ansible playbook is a YAML file with list of instructions that executes against the hosts. It is an organized and systematic unit of scripts which defines work for a server configuration executed by the automation tool Ansible.

Create a file named ansible-playbook.yml and paste the code below. In this playbook, we are specifying two tasks (namely installing apache2 and starting apache2) to be performed on the localhost.

---
- name: installing and starting apache2
  hosts: localhost
  become: yes

  tasks: 
    - name: installing apache2
      apt: 
        name: apache2 
        state: present

    - name: start nginx
      service: 
        name: apache2
        state: started
        enabled: yes

Notice that we are running the playbook against localhost. This is because we are successfully logged into the host server. However, it is possible to run a playbook against multiple hosts. This is done with the use of an inventory file. Read more: Ansible Inventory.

Test and deploy the Ansible Playbook configuration

To test the configuration and check for errors, run the command below. This would check the correctness of the playbook.

ansible-playbook ansible-playbook.yml --ask-become-pass --check

Deploy the configuration.

Run the Ansible playbook below to provision and start the Apache2 web server.

ansible-playbook ansible-playbook.yml --ask-become-pass

Once the playbook has finished running, Apache will be configured on the Virtual Machine. You can test the configuration by opening a web browser and navigating to the public IP address of the VM. You should see the Apache web server homepage.

Conclusion

Thanks for reading. Let me know if you found this helpful. You are welcome to follow me on LinkedIn and Twitter @Paschal_ik.

Coming Up Next:
Install LAMP STACK on an Azure Virtual machine
Enable SSL on a Custom Domain on an azure Virtual Machine

References:

Installing Ansible — Ansible Documentation

Installing Packages — Python Packaging User Guide

Create Azure Virtual Machine (Linux VM) with Terraform

Paschal Ogu — Mon, 29 May 2023 04:20:02 +0000

Azure Virtual Machines provide a flexible and scalable solution for running your applications in the cloud. By leveraging Terraform, we can automate the creation and configuration of VMs, ensuring consistency and reproducibility in our deployments. We will specifically focus on Linux VMs, as they are widely used for various purposes, such as web hosting, application deployment, and data analysis.

In this article, we will go through the steps of using Terraform to create an Azure Virtual machine with the following resources: Azure Resource Group, Azure Virtual Network, Network Subnet, Public IP address, Network Security Group, Network Interface, Linux Virtual Machine.

Prerequisites
Install and Configure Azure CLI
Install and Configure Terraform
Provision the Infrastructure on Azure
Destroy the infrastructure
Conclusion

Prerequisites

An azure account and subscription: If you don't have an Azure subscription, create a free account before you begin.
Infrastructure-as-Code Basics: Basic understanding of infrastructure as code is required to follow along.

Terraform is a declarative open-source “Infrastructure as Code" tool, created by HashiCorp, that enables the definition of on-premises and cloud resources in human-readable configuration files that can be versioned, reused, and shared as code.

Install and Configure Azure CLI

Open a command line from any device that has access to the Azure CLI. For steps on how to configure azure CLI locally, refer to this Microsoft Documentation

sudo apt update
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Run the command az --version to confirm this has been installed successfully.

Install and Authenticate Terraform to Azure

Install Terraform

Depending on your operating system, the command to install terraform may be slightly different. Refer to the terraform documentation for system-specific instruction: Terraform Installation Guide

sudo apt update
sudo snap install terraform --classic

Run terraform --version command to view the version on terraform installed.

terraform --version

Make a Repository to hold our Terraform files and change the directory to this newly created repository.

mkdir Terraform
cd Terraform

Authenticate Terraform to Azure using a Microsoft Account

You can either authenticate to Azure using a Microsoft account or by using a service principal. In this blog, we will authenticate using a Microsoft account.

Run az login without any parameters and follow the instructions to sign in to Azure. When you log in successful, az login will display a list of the Azure subscriptions associated with the logged-in Microsoft account, including the default subscription.

az login

If you want to use a specific subscription, run the command below to show and set the required subscription.

az account show
az account set --subscription "<subscription_id_or_subscription_name>"

Provision the Infrastructure on Azure

Create a file to provision virtual machine on Microsoft Azure. This file will create following resources: Azure Resource Group, Azure Virtual Network, Network Subnet, Public IP address, Network Security Group, Network Interface, Linux Virtual Machine. We will call the file main.tf.

nano main.tf

Copy and paste the code below into the file created above

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "main" {
  name     = "${var.prefix}-resources"
  location =  "eastus"
}

resource "azurerm_virtual_network" "main" {
  name                = "${var.prefix}-network"
  address_space       = ["10.0.0.0/22"]
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
}

resource "azurerm_subnet" "internal" {
  name                 = "internal"
  resource_group_name  = azurerm_resource_group.main.name
  virtual_network_name = azurerm_virtual_network.main.name
  address_prefixes     = ["10.0.2.0/24"]
}

resource "azurerm_public_ip" "public_ip" {
  name                = "acceptanceTestPublicIp1"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location
  allocation_method   = "Dynamic"
}

resource "azurerm_network_interface" "main" {
  name                = "${var.prefix}-nic"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.internal.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.public_ip.id
  }
}

resource "azurerm_network_security_group" "nsg" {
  name                = "ssh_nsg"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name

  security_rule {
    name                       = "allow_ssh_sg"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
  security_rule  {
    name                       = "allow_publicIP"
    priority                   = 103
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

resource "azurerm_network_interface_security_group_association" "association" {
  network_interface_id      = azurerm_network_interface.main.id
  network_security_group_id = azurerm_network_security_group.nsg.id
}

resource "azurerm_linux_virtual_machine" "main" {
  name                            = "${var.prefix}-vm"
  resource_group_name             = azurerm_resource_group.main.name
  location                        = "eastus"
  size                            = "Standard_D2s_v3"
  admin_username                  = "adminuser"
  admin_password                  = "The$admin#password"
  disable_password_authentication = false
  network_interface_ids = [
    azurerm_network_interface.main.id,
  ]

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  os_disk {
    storage_account_type = "Standard_LRS"
    caching              = "ReadWrite"
  }
}

Remember to change the admin password to a string with your desired password (e.g. admin_password = "253P@assWord!@#".

Next, create a terraform variable file with name variable.tf

variable "prefix" {
  description = "The prefix which should be used for all resources in this example"
}

variable "location" {
  description = "eastus"
}

Run Terraform init to initialize the repository.

To see changes that will take effect before any action run terraform plan.

terraform plan

When prompted for location, enter your preferred location e.g. eastus

When prompted for prefix, enter the prefix that will be prepended to all resources created by terraform.

To apply the changes to our Azure environment, run the command below terraform apply to apply the changes. This should go off and provision the resources in your azure cloud environment.

terraform apply

To see a list of resources provisioned, run the terraform state list command.

terraform state list

Destroying the infrastructure

Run the below command and type yes to destroy the infrastructure

terraform destroy

Conclusion:

In this article, we harnessed the power of Terraform for infrastructure as code to provision resources on Azure. Firstly, we installed and configured Azure CLI on local device, installed and authenticated Terraform to provision infrastructure and resources on Azure. At the end, we destroyed the infrastructure to avoid incurring much cost.

Thanks for reading. Let me know if you found this helpful. You are welcome to follow me on LinkedIn → Paschal Ogu and Twitter → Paschal_ik.

Coming Up Next:

Configure Apache web server on Linux Virtual Machine using Ansible
Enable SSL on a Custom Domain
Install LAMP STACK on an Azure Virtual machine

References:

Terraform on Azure documentation – Articles, samples, references, and resources – Terraform on Azure
Terraform | HashiCorp Developer Terraform Documentation

Manage Profiles in VS Code

Paschal Ogu — Thu, 02 Mar 2023 17:07:28 +0000

In Visual Studio Code, a profile is a set of settings that help you customize your environment for your projects. Profiles are a great way to customize VS Code to better fit your need. You can save a set of configurations such as settings, extensions, font size, color theme etc., sync them across your devices, and even easily share them with colleagues. You can create multiple profiles for different scenarios.

For example, a python project might require specific extensions to run python script smoothly, while a Golang project will require different extensions and settings.

In another use case, you can create a profile with a specific set of extensions and settings like font size, and color theme for a demo project. By doing this, the demo will not mess up your normal VS Code setup, and you can customize VS Code for better visibility during your demo.

How to Create a Profile in VS Code

On Windows

To create a new profile, navigate to the top left of your screen, Click File > Preferences > Profiles > Create Profile.

For macOS

Navigate to Code > Preferences > Profiles > Create Profile.

Alternatively, you can click on settings (gear ⚙️ Icon) at the bottom left of your screen > Profiles > Create Profile. This works for both macOS and windows.

In the image above, I have created a DevOps VS Code profile to meet my DevOps needs.

When creating a profile, you can choose either “Create an Empty Profile” or “Create from current profile”.

Selecting “Create from Empty Profile” above will create a new profile without any customizations as though you just downloaded and installed VS Code, while creating from current profile will carry/include all changes or settings, if any exists.

Manage Profiles

You can easily switch, rename, create, delete, export or import profiles in VS Code by following the prompts on your screen.

Sync Profiles:

Enable profiles to sync across all devices by using the setting sync feature. With this setting sync enabled, creating and deleting a profile from one device, creates and deletes it across all your synced devices respectively.

Is VS Code Profile a feature you would like to explore? Share your thoughts in the comments section.

💡 This article was first published at blog.paschalogu.com. If you found it useful, follow me on Twitter and also on LinkedIn. Thanks for reading!

Set Up Terraform in your Jenkins Docker Container

Paschal Ogu — Sat, 04 Feb 2023 09:32:30 +0000

Organizations can automate their infrastructure as code (IaC) and streamline deployment processes by configuring a continuous integration and continuous development (CI/CD) pipeline to integrate Terraform within their Jenkins Docker container.

Terms:

Jenkins is an automation server widely used to automate various aspects of software development, including building, testing, and deploying applications.

Docker is an open-source platform that enables developers to build, deploy, run, update and manage applications in a container.

Containers are isolated environments that package an application and its dependencies together, allowing it to run consistently across different computing environments.

Terraform is a declarative open-source “Infrastructure as Code” tool, created by HashiCorp that enables the definition of on-prem and cloud resources in human-readable configuration files that can be versioned, reused, and shared as code.

In this artcle, we are going to set up terraform in a jenkins server that runs on a docker container. Let's get into it 🧑🏽‍💻

Step 1: Pull and start the Jenkins Docker container:

The Jenkins server used in this project was installed using the documentation. See more

docker run -d -v jenkins_home:/var/jenkins_home -p 8080:8080 -p 50000:50000 --restart=on-failure jenkins/jenkins:lts-jdk11

Step 2: Install Terraform on your Docker Container

To install terraform on the container, find your Jenkins container ID and log into the container as root user:

docker ps
docker exec -u 0 -it <container_id> /bin/bash

Change Directory to /usr/bin directory

cd /usr/bin

As the root user, install terraform in the docker container: Reference the official documentation for the installation guide.

wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

💡 If sudo and wget above are not found, they can be installed by running the below commands:

apt-get install sudo
apt-get install wget

Confirm that terraform has been installed by running the command to view its version:

terraform --version

Step 3: Install Terraform Plugin

From your Jenkins dashboard navigate to Manage Jenkins >> Manage Plugins and select the Available tab. Locate this plugin by searching for Terraform and clicking on install.

After installation of this plugin, ensure that it is enabled.

Step 4: Configure Terraform Path

Navigate to Jenkins UI and update the path to the terraform installation path:

Dashboard >> Manage Jenkins >> Global Tool Configuration >> Scroll down to Terraform and click on Terraform Installations.

Type in the installation path >> uncheck the install automatically >> apply changes and save.

That's it! You are now ready to write a CI/CD pipeline script to integrate terraform to automate infrastructure as code (IaC) in your Jenkins Docker container.

💡 This article was first published at blog.paschalogu.com. If you found it useful, follow me on Twitter and also on LinkedIn.