DEV Community: Hossain Chisty

Step-by-Step Guide: Building a Node.js App with CircleCI Configurations for Efficient Continuous Integration and Deployment

Hossain Chisty — Fri, 19 May 2023 11:39:19 +0000

Greetings, dear readers! We're thrilled to have you join us for yet another exciting article where we delve into the world of building CI/CD pipelines. So, without further ado, let's dive right into the heart of our discussion!

CircleCI is a popular continuous integration and delivery platform that helps automate the build, test, and deployment processes for software projects. In this article, we will explore how to build a Node.js application using CircleCI configurations. We'll cover the steps required to set up CircleCI, define the configuration file, and integrate it with a Node.js project.

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

A functioning Node.js development environment is installed on your machine.
A version control system, such as Git, for efficient code management.
A GitHub repository or an alternative platform to host your Node.js application.

Step 1: Setting Up CircleCI:

If you don't already have one, create an account on the CircleCI website (https://circleci.com/).
Establish a connection between CircleCI and your GitHub repository by accessing the "Projects" section and selecting "Set Up Project."
Grant CircleCI appropriate access permissions to your chosen repository.

Step 2: Defining the CircleCI Configuration File:

At the root of your Node.js project, create a file called .circleci/config.yml
Open the config.yml file and define the configuration specific to your project. Below is an example configuration to assist you in getting started:

version: 2.1

orbs:
  node: circleci/node@1.1.6

jobs:
  build:
    docker:
      - image: circleci/node:14
    steps:
      - checkout
      - run: npm install
      - run: npm test
    working_directory: ~/app

  test:
    docker:
      - image: circleci/node:14
    steps:
      - checkout
      - run: npm install
      - run: npm test
    working_directory: ~/app

  deploy:
    docker:
      - image: circleci/node:14
    steps:
      - run:
          name: Deploy app
          command: echo "Deploying to production server"
    working_directory: ~/app

workflows:
  version: 2
  build_and_test_deploy:
    jobs:
      - build
      - test:
          requires:
            - build # only test if the build job has completed
      - deploy:
          requires:
            - test # only deploy if the test job has completed
          filters:
            branches:
              only: master # only deploy if the master branch

This configuration utilizes the CircleCI Node orb, which provides a predefined set of Node.js tools and configurations. It defines three jobs: build, test, and deploy. The workflow ensures that each job is executed sequentially, with dependencies and filters set up accordingly.

Step 3: Commit and Push to GitHub:

Commit the .circleci/config.yml file to your project's repository.
Push the changes to your GitHub repository.

Step 4: Triggering a Build on CircleCI:

Visit the CircleCI dashboard for your project and navigate to the project's page.
You should see a newly added project and a "Start Building" button. Click on it to trigger the first build.
CircleCI will now execute the defined steps in the configuration file and provide feedback on the build process.

Conclusion: Congratulations on successfully configuring CircleCI for your Node.js application! With CircleCI, you can streamline your development workflow, automate crucial processes, and focus more on what you love—coding! Enjoy the convenience and efficiency CircleCI brings to your project. Happy coding!

CI/CD pipeline setup: Building and pushing Docker images to Docker Hub using GitHub Actions

Hossain Chisty — Thu, 04 May 2023 10:50:17 +0000

The present article aims to elucidate the process of pushing a Docker image to DockerHub via GitHub Actions. By automating the building and pushing of Docker images to DockerHub, developers can reap various advantages such as enhanced consistency, efficiency, version control, ease of deployment, and scalability.

Create a GitHub repository and place a Dockerfile in the root directory.

Let's create a workflow with the following steps:

Check out the repository: This step will check out the code from your repository.

- name: Checkout code
  uses: actions/checkout@v2

- name: Login to Docker Hub
  uses: docker/login-action@v1
  with:
    username: ${{ secrets.DOCKER_USERNAME }}
    password: ${{ secrets.DOCKER_PASSWORD }}

Note: You will need to add your Docker Hub username and password as secrets in your repository settings.

Build the Docker image: This step will build the Docker image using the Dockerfile in your repository.

- name: Build Docker image
  run: docker build -t <dockerhub-username>/<image-name>:<tag> .

Note: Replace with your Docker Hub username, image name, and tag for the image.

Here's the complete workflow file:

name: Build and Push Docker Image

on:
  push:
    branches: [main]

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Login to Docker Hub
      uses: docker/login-action@v1
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    - name: Build Docker image
      run: docker build -t <dockerhub-username>/<image-name>:<tag> .

    - name: Push Docker image to Docker Hub
      run: docker push <dockerhub-username>/<image-name>:<tag>

Save this file as docker.yml in the .github/workflows/ directory of your repository, and GitHub Actions will automatically build and push the Docker image to Docker Hub every time you push changes to the main branch.

In case you don't know how to add secrets to your GitHub repository, follow these steps:

Go to your repository on GitHub and click on the "Settings" tab.
Click on "Secrets" in the left-hand menu.
Click on "New repository secret".
Give your secret a name (e.g. DOCKER_USERNAME or DOCKER_PASSWORD).
Enter the value of the secret in the "Value" field. Click on "Add secret".

I hope you found this article informative and useful for your Docker image building and pushing needs. If you have any questions or comments, feel free to leave them below. I look forward to seeing you in the next article!

Take Care. Keep smiling. :)

Dockerizing a Node.js Application from Scratch

Hossain Chisty — Sat, 29 Apr 2023 11:55:51 +0000

Dockerizing a Node.js application can greatly simplify the deployment process and improve the scalability of your application. Docker is a containerization platform that allows you to package your application and its dependencies into a container, which can then be run on any platform that supports Docker.

In this article, we'll go over the steps required to Dockerize a Node.js application from scratch.

Step 1: Create a Node.js Application
The first step is to create a Node.js application that we want to Dockerize. For this, we'll use the Express.js framework, which is a popular web application framework for Node.js.

To create an Express.js application, we first need to install Node.js and the npm package manager on our machine. Once we have Node.js and npm installed, we can create a new Express.js application by running the following command:

npx express-generator-esmodules myapp

This will create a new Express.js application in a directory called myapp. Once the application is created, we can navigate into the directory and install its dependencies using npm:

cd myapp
npm install

Step 2: Create a Dockerfile
The next step is to create a Dockerfile, which is a configuration file that describes how to build a Docker image for our Node.js application.

Create a new file called Dockerfile in the root directory of your application and add the following content:

# Use an official Node.js runtime as a parent image
FROM node:slim

# Set the working directory to /app
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application code to the working directory
COPY . .

# Expose port 3000
EXPOSE 3000

# Start the application
CMD [ "npm", "start" ]

Let's go through this Dockerfile line by line:

FROM node:slim: This line specifies that we want to use the official Node.js runtime as the base image for our Docker image. Slim is a lightweight Linux distribution that's commonly used for Docker images because of its small size.
WORKDIR /app: This line sets the working directory for our Docker image to /app.
COPY package*.json ./: This line copies the package.json and package-lock.json files to the working directory.
RUN npm install: This line installs the dependencies listed in package.json.
COPY . .: This line copies the rest of the application code to the working directory.
EXPOSE 3000: This line exposes port 3000, which is the port that our Node.js application will listen on.
CMD [ "npm", "start" ]: This line specifies the command to run when the Docker container starts. In this case, we're starting our Node.js application using the npm start command.

Step 3: Build the Docker Image
Now that we have a Dockerfile, we can use it to build a Docker image for our Node.js application. To do this, we'll use the docker build command.

Open a terminal window, navigate to the root directory of your application, and run the following command:

docker build -t myapp .

This command tells Docker to build a new image using the Dockerfile in the current directory, and tag it with the name myapp. The . at the end of the command specifies the build context, which is the directory that Docker uses as the root of the build process.

Step 4: Run the Docker Container
Now that we have a Docker image for our Node.js application, we can use it to run a Docker container. To do this, we'll use the docker run command.

Open a terminal window and run the following command:

docker run -p 3000:3000 myapp

This command tells Docker to run a new container using the myapp image that we just built, and map port 3000 from the container to port 3000 on the host machine. This allows us to access our Node.js application running inside the container from our web browser.

If everything is set up correctly, you should see output in the terminal window indicating that your Node.js application is running. You can now open a web browser and navigate to http://localhost:3000 to see your application in action.

Conclusion
In this article, we went over the steps required to Dockerize a Node.js application from scratch. We started by creating a new Node.js application using the Express.js framework, then created a Dockerfile that described how to build a Docker image for our application. We then built the Docker image and ran a Docker container using that image. By following these steps, you should now have a fully Dockerized Node.js application that can be easily deployed and scaled.

Thank you for your time!

How I Build ERP Software With Django

Hossain Chisty — Wed, 07 Sep 2022 13:33:27 +0000

Today I will share with you one of my favorite project build with Django. Let me explain what it does and how it helps people to use this product.

Freshdesk is smart ERP solution to manage your business. you can keep track of your accounts, customers, products, orders, invoices, expense, purchase, report, return, damage, sales, service, stock, suppliers and more. It’s easy-to-use for keeping all kinds of business records.

Let's discuss about key features:

✅ Activity Dashboard

✅ Account Management

✅ Product Management

✅ Sells Products by Barcode & QR-Code

✅ Purchase Management

✅ Stock Management

✅ Sales Management

✅ Service Management

✅ Expense Management

Real-Time pie chart that shows expense by current year and month. We’ll notify you when an expense syncs.

✅ Damage Management

✅ Customer Management

✅ Supplier Management

Some noticeable features:

✅ Engagement Tracking

✅ Export excel, csv files (Automatically Generated)

✅ View Connected Device

✅ Device Activity Tracking

✅ PDF Report (Automatically Generated)

✅ Accessing & Downloading your Freshdesk Information
Get a copy of your data. We’ll email you a link to a file with your information. it may take up to 48 hours to collect this information and send it to you.

✅ Two-Factor Authentication (2FA) In Admin

Click here to see project on GitHub