DEV Community: Otobong Edoho

Using Dockerfile and Docker Compose For Local Development with Node.js, MongoDB and MongoExpress

Otobong Edoho — Tue, 15 Oct 2024 11:03:43 +0000

Introduction

In this post, I'll show you how to set up a local development environment using Docker with Node.js, MongoDB, and MongoExpress. Docker is a powerful tool that makes it easy to package applications and their dependencies, ensuring consistency across different environments.

The goal of this guide is to help you spin up a simple Node.js app connected to a MongoDB database. We'll also use MongoExpress as a lightweight web-based interface to manage the database, all running inside Docker containers. By the end of this post, you’ll have a fully functional environment that can be set up and torn down with just a few commands.

Prerequisites
Before we dive in, please make sure you have the following installed:

Docker: You can download and install Docker from here.
Basic understanding of Node.js and MongoDB.
An EC2 Cloud instance for Non-ubuntu users

If you’re new to Docker, there's no need to worry! This guide will walk you through the essential commands you need to know to get your environment up and running.

Setting up the Project

Setup for Docker
So we will start setting up the project, The first thing we need to do is pull the mongodb images and mongo express UI image from dockerhub.

Let's install docker but first we need to update the package lists

sudo apt update
sudo apt upgrade -y

Install Required Dependencies
Install packages that allow apt to use repositories over HTTPS:

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

Add Docker’s Official GPG Key

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

Set Up the Docker Repository
Add the Docker repository to apt sources:

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

Install Docker Engine

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Now that docker is installed its time to pull the images
Let's pull the mongodb image first

The docker run command does two things, it pulls the image and runs the image which is what we call a container. A container is the running instance of an image.

Docker containers run in an isolated network meaning if we are running two different containers and we want them to be able to communicate we must put them in the same network.

Explanation of the Screenshot:

`docker run`:

This command starts a new container from a Docker image.

`-d`:

The -d flag tells Docker to run the container in "detached" mode (in the background), so it won't block the terminal.

`-p 27017:27017`:

This option maps port 27017 on the host machine to port 27017 in the container. MongoDB uses this port for communication.

The syntax is host_port:container_port, which means MongoDB will be accessible via localhost:27017 on the host machine.

`--network mongo-network`:

This option connects the container to a Docker network named mongo-network. The network allows multiple containers to communicate with each other.

If the network doesn't exist, create it with docker network create mongo-network.

`--name mongodb`:

This assigns a name (mongodb) to the running container. It allows you to refer to the container by name rather than by its container ID.

`-e MONGO_INITDB_ROOT_USERNAME=admin`:

The -e flag sets environment variables inside the container. In this case, it sets MONGO_INITDB_ROOT_USERNAME to admin, which specifies the MongoDB root user's username.

`-e MONGO_INITDB_ROOT_PASSWORD=changethis123`:

Similar to the previous option, this sets the environment variable MONGO_INITDB_ROOT_PASSWORD to changethis123, defining the password for the MongoDB root user.

`mongo`:

This is the name of the image to use. In this case, it is the official MongoDB image from Docker Hub.

Now that we have some knowledge about docker let's proceed to pull the mongodb express image and run it

To check the network available, we can run
docker network ls

It will output the name of the network that we just created, so they can talk to each other using just the container name.

So we can access the mongo express server from our browser using localhost:8081

Now there's a quicker and better setup, that is using dockerfile and docker compose rather than just running the commands in the terminal. Just to be clear a Docker Compose file uses YAML syntax, it defines how to configure and run multi-container applications on Docker while a Dockerfile is a text file that contains instructions for building a container image.

Setting up the Project

First, let's create a simple Node.js application. If you don't already have Node.js installed, you can download it here.

Start by creating a project folder:

   mkdir docker-node-mongo
   cd docker-node-mongo

Initialize a new Node.js project:

   npm init -y

Install the necessary dependencies. For this setup, we’ll need Express for our web server and Mongoose to interact with MongoDB:

   npm install express mongoose

Create an index.js file with a simple Express server and a MongoDB connection using Mongoose:

   const express = require('express');
   const mongoose = require('mongoose');

   const app = express();
   const port = 3000;

   // MongoDB connection
   mongoose.connect('mongodb://mongo:27017/testdb', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
   }).then(() => {
     console.log('Connected to MongoDB');
   }).catch(err => {
     console.log('Failed to connect to MongoDB', err);
   });

   // Routes
   app.get('/', (req, res) => {
     res.send('Hello from Node.js and MongoDB');
   });

   app.listen(port, () => {
     console.log(`App running at http://localhost:${port}`);
   });

This sets up a basic Express server and connects it to a MongoDB instance running on mongodb://mongo:27017/testdb. Now let's Dockerize it.

Creating a Dockerfile for Node.js

Next, we need to create a Dockerfile that will define the environment for our Node.js app. A Dockerfile is essentially a blueprint for building the Docker image that will contain your application.

Create a file called Dockerfile in the root of your project directory and add the following:

# Use the official Node.js image from Docker Hub
FROM node:16

# Set the working directory inside the container
WORKDIR /app

# Copy package.json and install dependencies
COPY package*.json ./
RUN npm install

# Copy the rest of the app files
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Command to run the app
CMD ["node", "index.js"]

This Dockerfile will:

Use the official Node.js image.
Set the working directory to /app.
Copy the package.json and install the necessary dependencies.
Copy the rest of the files and set the entry point to run the Node.js app.

Setting up MongoDB and MongoExpress with Docker Compose

Instead of running all services separately, we'll use Docker Compose to define and manage our multi-container environment. Docker Compose allows us to define services, networks, and volumes in a docker-compose.yml file, making it easy to orchestrate our entire stack. One thing to remember is that when using docker compose we don't need to create a network it automatically creates a network for our multiple containers defined in the yaml file.

Create a docker-compose.yml file in the project root:

version: '3'
services:
  nodeapp:
    build: .
    ports:
      - '3000:3000'
    volumes:
      - .:/app
    depends_on:
      - mongo
  mongo:
    image: mongo
    ports:
      - '27017:27017'
  mongo-express:
    image: mongo-express
    ports:
      - '8081:8081'
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: example
      ME_CONFIG_MONGODB_SERVER: mongo

This configuration defines three services:

nodeapp: Our Node.js application.
mongo: A MongoDB instance running on port 27017.
mongo-express: A web-based interface to manage MongoDB, accessible on port 8081.

Running the Application

With everything set up, let’s run the app using Docker Compose.

Run the following command in your terminal:

docker-compose up

To shut down the multiple containers currently using Docker Compose

docker-compose down

Docker Compose will pull the necessary images, build the Node.js app, and start all services. After the process completes, you should see logs from MongoDB, Node.js, and MongoExpress.

Visit http://localhost:3000 to see the Node.js app running.
Visit http://localhost:8081 to access MongoExpress and manage your database.

Connecting Node.js to MongoDB

Our Node.js app is already set up to connect to MongoDB with the following connection string inside index.js:

mongoose.connect('mongodb://mongo:27017/testdb', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

The mongo hostname refers to the MongoDB service defined in our docker-compose.yml. Docker Compose automatically creates a network for the services, allowing them to communicate by their service names.

Conclusion

In this post, we’ve successfully set up a local development environment using Docker for Node.js, MongoDB, and MongoExpress. Using Docker Compose, we orchestrated multiple containers to work together seamlessly, making it easier to spin up a fully functional stack for development.

With this setup, you can easily add more services, manage your databases with MongoExpress, and have an isolated environment without needing to install MongoDB or other dependencies locally.

Happy Reading!!! Please Like, save, share and follow!!!

How to Publish a Java Artifact Built with Gradle to a Nexus Repository part 1

Otobong Edoho — Wed, 28 Aug 2024 12:41:29 +0000

What is a Nexus repository?

Nexus repository is a publicly accessible repository manager from Sonatype that organizes, stores and helps in distribution of artifacts used in software development.

It has built in support many for artifact formats such as Docker, Java, Go, PHP, Python etc.

Artifacts simply put refers to outcome of software build and packaging process

Importance of Publishing Java Artifacts to a Central Repository

Publishing Java artifacts to a central repository, like Nexus, is an important practice in modern software development for several reasons:

Team Collaboration: In a team environment, a central repository allows developers to share libraries, frameworks, or any reusable code easily.
Integration with CI/CD Pipelines: Publishing to a central repository is often a key step in CI/CD pipelines. Artifacts can be automatically deployed to a repository after a successful build, making them immediately available for testing or production deployment.
Version Control: Central repositories allow developers to manage multiple versions of an artifact. This enables the use of specific versions, ensuring compatibility and stability across different project development.

Prerequisites

Java Development Kit 17 installed.
Gradle installed and configured.
Access to a Nexus Repository (public or private).
Basic understanding of Gradle build scripts (build.gradle).
An EC2 Instance or any other Cloud Service

Install Nexus

So before we install nexus we will setup an EC2 instance where we can install and run nexus.

To install Java on the instance

apt install openjdk-17-jre-headless

When that is done you can install nexus using this command



cd /opt
wget https://download.sonatype.com/nexus/3/nexus-3.71.0-06-unix.tar.gz
ls

It comes as a tar ball so we need to extract it

tar -xvzf nexus-3.71.0-06-unix.tar.gz

Run ls and you should see this

Run ls -l to see the files and the owners, the root has ownership to the files so we need to give ownership to a nexus user which we will create. It is best practice to always create a user for any service we want to run.

Let's create a nexus user and add the user to nexus group



adduser nexus
usermod -aG nexus nexus

while still in the /opt directory run this command



chown -R nexus:nexus nexus-3.71.0-06
chown -R nexus:nexus sonatype-work

Set nexus config so it will run as a nexus user
vim nexus-3.71.0-06/bin/nexus.rc

This should open up the file in vim edit the run_as_user="nexus" like this

Now switch to the nexus user and run the nexus service



su - nexus
/opt/nexus-3.71.0-06/bin/nexus start

Use the command below to check the service and on which port running.

We can see that nexus is running in port 8081, if the port is blocked on your EC2 instance you need to configure the security groups to allow inbound traffic on that port.

Next Use the public IP address of your instance and the nexus port number like this
18.232.173.21:8081
to be able to access the nexus interface from our browser

To get the default password for the admin interface navigate to the following directory



/opt/sonatype-work/nexus-3.71.0-06/
cat admin.password

Use that to login, the username is admin

After logging in the admin interface should look like this

maven-releases repository is where we store artifacts that have been tested and are ready to be deployed to production.
maven-snapshots repository is where we store artifacts that are still in the development and test phase.

Let's say a developer in our company want to publish an artifact to nexus we can't let them use the admin account, we must create an account for that user

Navigate to the Users tab and create local user

Go to User roles and create a role for the created user

Best Practice: We don't want our user having too many privileges so we will only assign a role in which the user needs to carry out a task

We are building with gradle in this case but the role still works the same as maven so we will set the following role

Now we Assign that role that we created to the user

Configure Gradle with Nexus
Apply the following configurations and plugin to the build.gradle file



group = 'com.example'
version = '1.0.0-SNAPSHOT'
sourceCompatibility = '17'
targetCompatibility = '17'

apply plugin: 'maven-publish'

This code block publishes the artifact that we have built



publishing {
//  The Artifacts we are going to upload
    publications {
        maven(MavenPublication) {
            artifact("build/libs/java-react-example-${version}.jar") {
                extension 'jar'
            }
        }
    }

This code block defines the address that we are going to publish to.
The allowInsecureProtocol = true
Allows the publishing to work regardless of the fact that we are not using https
The credentials declares the user account that we created on our Nexus repository, so it will give access for our user to publish to the repository



// The Nexus repo that we will upload the Jar file to
    repositories {
        maven {
            name 'nexus'
            url "http://[Your Public IP]:8081/repository/maven-snapshots/"
//        So that it will all HTTP
            allowInsecureProtocol = true
            credentials {
                username project.repoUser
                password project.repoPassword
            }
        }
    }
}

Let's create a gradle.properties in our project file to store our user secret



repoUser = oty
repoPassword = xxxxxxxxxxx

Create a settings.gradle file if it doesn't exist and add the project name



rootProject.name ='java-react-example'

If you haven't already built the project run then publish it



gradle build
gradle publish

Now we can go to our nexus repository and view our publish artifact

Happy Reading!!!
Please Like and Follow if You liked the Article.
Thank You.

Git Commit Hacks Every Developer Should Know

Otobong Edoho — Tue, 20 Aug 2024 11:23:52 +0000

1. Mastering Git Commit: The Foundation of Version Control

The git commit command is the bedrock of Git. Each commit represents a snapshot of your project at a particular point in time. Here’s how to make the most of it:

Atomic Commits
Atomic commits are all about keeping each commit focused and self-contained. When you make small, focused commits, it becomes easier to track down the source of bugs and understand the evolution of the project. Each commit should ideally address one specific issue or feature.

git commit

2. Undoing Mistakes: Git Revert vs. Git Reset
Mistakes happen. When they do, Git provides powerful tools to help you undo them.

Safe Reversal with git revert
If you need to undo a commit without altering the commit history, git revert is your best friend. Unlike git reset, which changes your history, git revert creates a new commit that undoes the changes introduced by a previous commit.

git revert <id>

This is especially useful in shared repositories where altering history can cause issues for others.

Hard Reset with git reset --hard <id>
On the other hand, git reset --hard is a more drastic measure. It resets your current branch to the specified commit, discarding all changes in the working directory and the index

git reset --hard <id>

3. Navigating History: Leveraging Git Checkout
git checkout <id> is a versatile command that allows you to switch between branches or revisit specific commits.

git checkout <id>

Exploring Old Versions with git checkout <id>
Sometimes, you need to look at an older version of your code to understand how a feature was implemented or to test an earlier state of the project. You can temporarily switch to an older commit using.

4. Understanding Git Log: Navigating Your Project’s History
The git log command is an essential tool for any developer working with Git. It allows you to view the history of commits in a repository, providing a detailed log of all the changes made over time. Here's how you can make the most out of git log.

git log

By understanding these commands and when to use them, you can wield Git more effectively and maintain a clean, understandable project history.

Happy Reading!!!!!!!

Setting Up Postgresql Database for Servers

Otobong Edoho — Thu, 25 Jul 2024 21:23:53 +0000

Introduction

PostgreSQL is an advanced object relational database sytem that uses and also extends the SQL language. The good thing about postgreSQL that it is Open source.

Developers and Database administrators alike use postgreSQL because of it's high data consistencey and data integrity which proves to be more reliable than other SQL databases.

This is a stage 4 task that I worked on as HNG11 intern, It was a team based task, the team consisted of 6 members.

This post will cover

Installation of postgreSQL
Creation of the Database and user
Configuring PostgreSQL

Prerequisites

List of required tools and software (e.g., PostgreSQL, SSH client)
Basic knowledge required (e.g., familiarity with terminal commands, server access)

Install PostgreSQL along with its additional features

sudo apt install postgresql postgresql-contrib

Switch to the PostgreSQL user to perform the needed administrative tasks

sudo -i -u postgres

# opening  the sql prompt
psql

Within the PostgreSQL prompt, create the required databases for the production, staging and development environments

CREATE DATABASE langlearnai_be_staging_db;
CREATE DATABASE langlearnai_be_main_db;
CREATE DATABASE langlearnai_be_dev_db;

Create Users and assign passwords for each enviroment

CREATE USER langlearnai_be_staging_user WITH ENCRYPTED PASSWORD 'staging_password';
CREATE USER langlearnai_be_main_user WITH ENCRYPTED PASSWORD 'main_password';
CREATE USER langlearnai_be_dev_user WITH ENCRYPTED PASSWORD 'dev_password';

Grant the necessary Privileges to Users

GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_staging_db TO langlearnai_be_staging_user;
GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_main_db TO langlearnai_be_main_user;
GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_dev_db TO langlearnai_be_dev_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_staging_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_main_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_dev_user;

Exit the PostgreSQL prompt:

\q

Configure and modified the Postgres configuration files to allow PostgreSQL to Listen on External IP

sudo vim /etc/postgresql/13/main/postgresql.conf

Locate the listen_addresses line and change to:

listen_addresses = "*"

Open the pg_hba.conf file

sudo vim /etc/postgresql/13/main/pg_hba.conf

Add the following lines under IPV4 local connections to allow external access. i.e These lines configure PostgreSQL to accept connections from the specified IP address

# IPv4 local connections
host    all             all             0.0.0.0/0               md5
host    postgres        postgres        <server-ip-address>/32      md5
host    langlearnai_be_dev_db  langlearnai_be_dev_user  <server-ip-address>/32    md5
host    langlearnai_be_main_db  langlearnai_be_main_user  <server-ip-address>/32    md5
host    langlearnai_be_staging_db  langlearnai_be_staging_user  <server-ip-address>/32    md5

Restart to apply changes and enable the PostgreSQL service to start on system boot

sudo systemctl restart postgresql
sudo systemctl enable postgresql

Allow connections on port through firewall

sudo ufw allow 5432/tcp

Accessing the Database

To connect to the PostgreSQL database remotely, use the following command

psql -h your_server_ip -U your_database_username -d your_database_name

Happy Reading and Learning

Setting Up Postgresql Database for Servers

Otobong Edoho — Thu, 25 Jul 2024 21:23:53 +0000

Introduction

PostgreSQL is an advanced object relational database sytem that uses and also extends the SQL language. The good thing about postgreSQL that it is Open source.

Developers and Database administrators alike use postgreSQL because of it's high data consistencey and data integrity which proves to be more reliable than other SQL databases.

This is a stage 4 task that I worked on as HNG11 intern, It was a team based task, the team consisted of 6 members.

This post will cover

Installation of postgreSQL
Creation of the Database and user
Configuring PostgreSQL

Prerequisites

List of required tools and software (e.g., PostgreSQL, SSH client)
Basic knowledge required (e.g., familiarity with terminal commands, server access)

Install PostgreSQL along with its additional features

sudo apt install postgresql postgresql-contrib

Switch to the PostgreSQL user to perform the needed administrative tasks

sudo -i -u postgres

# opening  the sql prompt
psql

Within the PostgreSQL prompt, create the required databases for the production, staging and development environments

CREATE DATABASE langlearnai_be_staging_db;
CREATE DATABASE langlearnai_be_main_db;
CREATE DATABASE langlearnai_be_dev_db;

Create Users and assign passwords for each enviroment

CREATE USER langlearnai_be_staging_user WITH ENCRYPTED PASSWORD 'staging_password';
CREATE USER langlearnai_be_main_user WITH ENCRYPTED PASSWORD 'main_password';
CREATE USER langlearnai_be_dev_user WITH ENCRYPTED PASSWORD 'dev_password';

Grant the necessary Privileges to Users

GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_staging_db TO langlearnai_be_staging_user;
GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_main_db TO langlearnai_be_main_user;
GRANT ALL PRIVILEGES ON DATABASE langlearnai_be_dev_db TO langlearnai_be_dev_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_staging_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_main_user;
GRANT ALL PRIVILEGES ON SCHEMA public TO langlearnai_be_dev_user;

Exit the PostgreSQL prompt:

\q

Configure and modified the Postgres configuration files to allow PostgreSQL to Listen on External IP

sudo vim /etc/postgresql/13/main/postgresql.conf

Locate the listen_addresses line and change to:

listen_addresses = "*"

Open the pg_hba.conf file

sudo vim /etc/postgresql/13/main/pg_hba.conf

Add the following lines under IPV4 local connections to allow external access. i.e These lines configure PostgreSQL to accept connections from the specified IP address

# IPv4 local connections
host    all             all             0.0.0.0/0               md5
host    postgres        postgres        <server-ip-address>/32      md5
host    langlearnai_be_dev_db  langlearnai_be_dev_user  <server-ip-address>/32    md5
host    langlearnai_be_main_db  langlearnai_be_main_user  <server-ip-address>/32    md5
host    langlearnai_be_staging_db  langlearnai_be_staging_user  <server-ip-address>/32    md5

Restart to apply changes and enable the PostgreSQL service to start on system boot

sudo systemctl restart postgresql
sudo systemctl enable postgresql

Allow connections on port through firewall

sudo ufw allow 5432/tcp

Accessing the Database

To connect to the PostgreSQL database remotely, use the following command

psql -h your_server_ip -U your_database_username -d your_database_name

Happy Reading and Learning

DEV Community: Otobong Edoho

Using Dockerfile and Docker Compose For Local Development with Node.js, MongoDB and MongoExpress

Introduction

Setting up the Project

Explanation of the Screenshot:

docker run:

-d:

-p 27017:27017:

--network mongo-network:

--name mongodb:

-e MONGO_INITDB_ROOT_USERNAME=admin:

-e MONGO_INITDB_ROOT_PASSWORD=changethis123:

mongo:

Setting up the Project

Creating a Dockerfile for Node.js

Setting up MongoDB and MongoExpress with Docker Compose

Running the Application

Connecting Node.js to MongoDB

Conclusion

How to Publish a Java Artifact Built with Gradle to a Nexus Repository part 1

Git Commit Hacks Every Developer Should Know

Setting Up Postgresql Database for Servers

Introduction

Prerequisites

Accessing the Database

Setting Up Postgresql Database for Servers

Introduction

Prerequisites

Accessing the Database

`docker run`:

`-d`:

`-p 27017:27017`:

`--network mongo-network`:

`--name mongodb`:

`-e MONGO_INITDB_ROOT_USERNAME=admin`:

`-e MONGO_INITDB_ROOT_PASSWORD=changethis123`:

`mongo`: