DEV Community: joy

Creating Parametrized builds using Jenkins

joy — Tue, 09 Dec 2025 10:56:14 +0000

Introduction

Jenkins is a tool that makes life easier by automating the tasks we repeat over and over, whether it’s building code, running tests, or deploying an application. It is platform and environment agnostic, giving teams the freedom to integrate with almost any tool or technology. Acting as a centralized automation hub, Jenkins can be customized and extended through its extensive plugin ecosystem to fit nearly any workflow.

One feature that really brings out its flexibility is parameterized builds. Instead of creating a new job every time you want to deploy to a different environment or use a different version, you can simply add the options you want when starting the build. This enables a user to save on time, and allows a single job to run in multiple ways depending on your needs.

This article will show how Jenkins is able to use parameterized builds, that allow you to customize a job based on the inputs you provide before it runs. The steps below walk through how to set them up.

Prerequisites

1.Jenkins installed on your device.
2.Basic understanding of your project; Know what inputs you want to provide for example if it's environment, version or module.
3.A web browser to interact with Jenkins.

Step 1: Once Jenkins is installed, open it in a web browser using http://localhost:8080 and log in with the admin password.

Step 2: In the Jenkins dashboard, click Create Job, enter a name for your job, and select the Freestyle project option.

Step 3: After naming the job, go to the Configure tab to set up the parameterized build. Jenkins offers eight types of parameters, but for this tutorial, we’ll focus on String and Choice parameters. Start by creating a String parameter named Stage with a default value of Build.

Step 4 : Next, add a Choice parameter named Env with three values: Development, Staging, and Production.

Step 5: After adding the parameters, navigate to the Build section and click Add build step.

Step 6: Select Execute shell and enter commands that reference the Stage and Env parameters. For example we are using this in the build as shown in the previous:

echo "Current Stage: $Stage"
echo "Deploying to Environment: $Env"

Running these commands shows the parameter values you entered for the job, confirming they’re applied correctly and highlighting how they guide the job’s execution.

Step 7: Once done, save the job. You will be redirected to the job homepage. Click Build with Parameters to see the input fields and run the build.

Step 8: Select a value for Env (Development, Staging, or Production) as displayed above and trigger the build. After the build completes, click the build number to see the results. Select Console Output to view detailed information about the build execution as shown below.

The console output will show the messages from your shell commands, confirming which stage and environment were used for that run.

Conclusion

In conclusion, we were able create parameterized builds using Jenkins which makes creating jobs much more flexible. We used inputs like environment or version before running the job, therefore enabling it's reuse for different situations. Parameterized builds therefore saves time, and makes automation smoother and easier to manage.

Load balancing with Docker Swarm & Nginx

joy — Sun, 21 Apr 2024 12:48:10 +0000

Docker Swarm is a platform that enables deployment and hosting of clusters of docker hosts. Nginx is a web server that offers different services such as HTTP caching, load balancing, reverse proxying as well as mail proxying.
Load balancing is the distribution of equal resources across different servers to improve the performance of an application.

Let's say you're a teacher with a classroom full of students who all need your help at the same time. You have a big stack of papers to grade, questions to answer, and projects to review. If every student lines up in front of your desk to ask for help or submit their work, it's going to be chaotic and slow. Some students might have to wait a long time before they get the attention they need.
Load balancing in this scenario would be like having teaching assistants or group leaders who can help manage the workload. Each assistant can take a group of students and handle their questions, grade their papers, and provide feedback. This way, the workload is distributed among multiple helpers, making sure that everyone gets the support they need promptly without overwhelming you, the teacher.

This article will explore how to achieve load balancing with Nginx and Docker Swarm.

Prerequisites

Docker & Docker swarm installed.
Nginx installed.

Step 1: Start with creating a folder where your application will run and initialize Docker swarm. `docker swarm init`

Step 2: Create a Docker service with the name of your application, replicas needed ports, and image needed. We will use alpine as the choice of image. `docker service create --name yourappname --replicas 2 -p 8080:80 httpd:alpine`

Step 3: Configure nginx at the ‘’/etc/nginx/sites-available/default’’ file location with the following variables.

`
server {
listen 80;
server_name localhost;

location / {
    proxy_pass http://localhost:8080;  
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection 'upgrade';
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
}

}

Step 4: Save the configurations and restart the Nginx service.`sudo systemctl restart nginx`

Step 5: Go to the load balancing service using http://localhost or the IP address of your device. The screenshot displays that the site is actively working.

Nginx acts as the load balancer for the Docker swarm. It forwards traffic to the Docker swarm services running at port 8080

Conclusion

In conclusion, we were able to create a Docker swarm service that used Nginx to forward packets and offer load balancing to the traffic in the application. Docker swarm offers a versatile tool for clustering and orchestration of Docker containers.

Set up an Automation script with Ansible

joy — Sun, 21 Apr 2024 10:53:30 +0000

Ansible is a tool used to help manage software automation processes, configuration management across machines, deployment as well as remote execution of commands and scripts. In sports, Ansible operates as the coach of your team by providing strategies (playbooks), and actions, and ensuring the smooth execution of tasks across your infrastructure, just like a coach guides and directs players (Servers)during a game.

In Ansible, a playbook is a file containing a series of instructions that specify the tasks to be performed on remote systems. These tasks are typically related to configuration management, application deployment, system orchestration, and other automation processes. Playbooks are written in YAML format.

In Ansible, a server is a remote computer system that Ansible manages and interacts with using SSH (Secure Shell) or other connection methods. The servers can be virtual machines or cloud instances accessible within a network.

Prerequisites

Ansible is installed on your device.

Step 1: After installing Ansible, we create a directory where we store all the files needed.

Step 2: Create an inventory file (inventory.ini)in the directory and define our service. We add localhost as the testing environment.

Step 3: Create an Ansible playbook which is a yaml file. The Yaml file will define the tasks you would like to automate. In this scenario, we install and start an Apache Web server to localhost.

Step 4: We run the playbook using the ansible-playbook -i (inventory file) nameofyourplaybook.yaml.

Note : make sure to have enabled execute privileges in the playbook. I.e chmod +x [yourplaybook.yaml].

Step 5:Your playbook should run successfully with the following output.

Conclusion

In conclusion, we were able to create an automation script for installing Apache locally using Ansible. Although we explored on how to achieve load balancing with Ansible, there are other benefits and services Ansible offers like Infrastructure automation, configuration management, and deployment of applications across different servers.

Send notifications to Slack using Jenkins

joy — Mon, 26 Feb 2024 09:06:30 +0000

Introduction

Jenkins is a tool used by software engineers to automate builds, test, and deploy software by providing a centralized platform for managing workflows.

Imagine you're running a bakery, and you have a team of bakers who work together to bake different types of cakes. Each cake requires several steps, like mixing ingredients, baking, decorating, and packaging.

Now, Jenkins workflows are like having a super efficient system in your bakery that automates and manages all these steps seamlessly.Jenkins workflows streamline the entire process of developing and delivering software, just like your bakery's system ensures that each cake is made to perfection and delivered to the customer with care and efficiency.

This article will explore how Jenkins enables such efficiency by demonstrating how it allows this by sending notifications to Slack by using the Jenkins pipeline and a Slack bot.

Prerequisites

To follow along easily with this tutorial, you should have the following:

Jenkins installed on your device.
A Slack workspace.
Slack bot application created from scratch within your Slack workspace.
Jenkins pipeline created.

Step1 : We start by installing Jenkins and Java from the Jenkins official website.

Once done installing, we configure the admin credentials. We then go to the Jenkins dashboard and click on manage Jenkins.

Note
We would recommend following the Jenkins documentation installation guide to have the best installation without having any blunders with Jenkins keyrings. We used the long term support release installation.Make sure to start the Jenkins application with systemctl start jenkins after installing. We access Jenkins on the localhost:8080 port.

Step 2: Go to the plugins section and click on available plugins. Install Slack notifications and restart Jenkins once done with installation.

Step 3: Go to https://api.slack.comcreate an (slackbot)application from scratch and add your workspace.

(Attached is a screenshot of my app name and slack workspace. You can name the application whatever you like. We created a slack workspace for testing the application.)

Step 4: Once the app is created, we click on OAuth and permissions and add go to the bot token scopes.

We add the chat: write, files:write, chat:write.customize, reactions:write, users:read, users:read.email scopes.
Once done adding the scopes, we click install workspace which adds Jenkins to the slack workspace.

Step 5: Go to the Jenkins Dashboard and click on manage Jenkins + credentials.Click on the global domains where we add your Slack credentials.

Choose the secret text option; the scope option should be global.
The value of the secret is the OAuth token created in Slack. The ID and description can be anything we wish to add.

Step 6: Click on manage Jenkins then configure systems. Scroll to the bottom where Slack exists and add the Slack workspace name and Slackbot credentials created.

Add your default channel. We chose to use random as our default slack channel but you can choose any. Make sure to tick the box with the custom Slack bot user.

Note: If we encounter a crumb error/403 error, make sure to enable proxy compatibility in the Jenkins security tab.

Step 7: Once the values are added, apply and save the changes and test the connection for the Slack bot.

If successful we get a success and confirmation message on the selected (random)channel.

Step 8: Go to the Jenkins dashboard and click on a new item; name it what you wish and click the pipeline option.

With that you have created the Jenkins pipeline.

Step 9: Go to the advanced project options; add a pipeline script. You can modify the text message in the slackSend value.

Step 10: Save and apply the changes. Once done, you customize and build the pipeline message and it shows up in your selected Slack channel.

Conclusion.

In conclusion, we were able to create and send Slack notifications using Jenkins. We were able to achieve this using the Jenkins pipeline and the use of a slackbot.

Deploying flask app to Kubernetes using Minikube

joy — Wed, 31 Jan 2024 17:04:20 +0000

Introduction

Kubernetes manages the deployment, scaling, and operation of containerized applications across a cluster of machines. Kubernetes relies on tools such as container runtimes like Docker, to run the containers.

Before deploying the application with Kubernetes, you need to containerize the application using docker. This article shows how to deploy a Flask application on Ubuntu 22.04 using Minikube; a Kubernetes tool for local deployment for testing and free offering. Alternatively, you can deploy your container apps using Cloud providers such as GCP(Google Cloud), Azure(Microsoft) or AWS(Amazon).

Prerequisites

1.Docker installed on your device..NOTE: Make sure your docker version is below 25; to prevent errors associated with compatibility. We will be using Docker version 24.0.7.)

2.Minikube installed on your Device.
3.A Github repository to save your project files.
4.Flask installed in your device.
5.A Dockerfile.
6.Docker-compose yaml file.
7.Deployment and Service yaml files.
8.A requirement.txt file for flask dependencies.

Step 1:Creating a Dockerfile with the following:

In the file structure of the Dockerfile, we copy the requirements.txt before the files because of easier caching when modifications are done,and you can have an easier build with Docker.

(Ensure you add Flask and werkzeug with their consecutive versions in the requirements.txt file.)

# Use an official Python runtime as a parent image
FROM python:3.10.12

# Install python3-venv
RUN apt-get update && \
    apt-get install -y python3-venv
# Set the working directory to the name of the application
WORKDIR /app

# Copy the requirements file into the container at the application 
COPY requirements.txt /app/

# Create a virtual environment in /opt/env
RUN python3 -m venv /opt/env

# Install any needed packages specified in requirements.txt
RUN /opt/env/bin/pip install --no-cache-dir -r requirements.txt

# Copy the current directory contents into the container at the application
COPY . /app/

# Set environment variables
ENV PATH="/app/venv/bin:$PATH"

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Run flask application when the container launches
CMD ["/opt/env/bin/python", "-m","flask", "run","--host=0.0.0.0"]

Step 2:Creating a docker-compose yaml file with the following:

version: '3'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=sqlite:////data/mydatabase.db  # Set the desired database file path
    volumes:
      - ./:/data # Set the desired file path

  sqlite3:
    image: nouchka/sqlite3:latest
    stdin_open: true
    tty: true
    volumes:
      - ./:/data # Set the desired file path

Step 3: Run Docker Compose Commands.

docker-compose build
docker-compose up

Step 4: Load the Docker Image to Minikube.

Minikube is best suited for local development and testing, but it doesn't provide the same features and scalability as a full-scale production Kubernetes cluster.
Once installed, make sure to load the image name that you created with docker using this command
minikube image load your-image-name:tag.We used this for the app:minikube image load flask_web:latest. Runminikube image listto check if the image exists.

Step 5: Create a Kubernetes Deployments file.

Note: Make sure to add the image pull policy line as IfNotPresentto mitigate pull errors from images you have.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: your-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: your-app
  template:
    metadata:
      labels:
        app: your-app
    spec:
      containers:
      - name: your-container
        image: your-image-name:tag
        ports:
        - containerPort: 80
        imagePullPolicy: IfNotPresent

Step 6: Apply the deployment file to Minikube.

kubectl apply -f deployment.yaml

Step 7: Create a service file that exposes the flask application.

apiVersion: v1
kind: Service
metadata:
  name: your-service
spec:
  selector:
    app: your-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Step 8: Apply the service in minikube.

kubectl apply -f service.yaml

Step 9: Access the service.

To access the service, run the following command:
minikube service your-service If successful, it will launch in your browser.

Step 10: Stopping and deleting the Minikube cluster.

Once done, make sure you stop and delete the minikube cluster using the following commands:
minikube stop minikube delete

Conclusion

In conclusion, we were able to deploy a container application in Kubernetes using Minikube as a testing tool which offered the best local testing environment. Kubernetes is the best tool for container orchestration, deployment, and scaling at the high end, while Docker complements Kubernetes by containerizing its applications.

Containerizing your Go application using Docker

joy — Tue, 16 Jan 2024 09:52:11 +0000

Introduction

This article will explore how to containerize a simple golang web server application using Docker . You can use any Operating system to run your application,We use Ubuntu to build this application. In this article we use Docker commands as opposed to using a Dockerfile.

Prerequisites

1.Docker installed on your device.
2.A Github repository to save your project files
3.Golang installed in your device
4.VsCode Editor

What is Docker?

Docker is a framework used by developers to containerize software applications. Containerizing an application is when a bunch of code and all its components, like libraries and files, are executed within a hosted environment.

When a person dockerizes their application, they can access and run it on any platform supporting docker. The application run usually has many components like files and libraries; which get stored in a compressed file called a docker image.

The following steps are used to containerize an application using Docker.
Note: We will not be using a Dockerfile for this article.

Step 1:Cd into the directory that contains your code and libraries.

You will then run the following command in your terminal while in your project directory.

We used alpine as the base image for docker because of its minimal size and we wanted a small image for the application. But if someone wants a larger image of better performance,We would suggest using NGINX as an image base.

Step 2:Install the necessary build tools.

Step 3: Copy and install go dependencies for your application.

Step 4 : Run and build the Go application using docker build -o name-of-your-application.

Step 5: After building the application, you exit the container.

Step 6: Commit your changes to a new image.

You can use the container ID or name of the application to commit the changes.

Step 7: Finally run your custom image with the following command.

Note: As much as this is an interactive way of containerizing an application. It is highly recommended to use a Dockerfile to containerize an application.

Conclusion

In conclusion, we were able to containerize the Go application using Docker. Docker is an amazing tool for containerizing applications such that you can access your application anywhere as long as you have the images stored in a container registry reachable when run with Docker. If you plan on seeking to explore how to do this using a Dockerfile, I would suggest following this article.

Containerizing your Go application by using Docker

joy — Tue, 16 Jan 2024 09:52:11 +0000

Introduction

Prerequisites

1.Docker installed on your device.
2.A Github repository to save your project files
3.Golang installed in your device
4.VsCode Editor

What is Docker?

The following steps are used to containerize an application using Docker.
Note: We will not be using a Dockerfile for this article.

Step 1:Cd into the directory that contains your code and libraries.

You will then run the following command in your terminal while in your project directory.

Step 2:Install the necessary build tools.

Step 3: Copy and install go dependencies for your application.

Step 4 : Run and build the Go application using docker build -o name-of-your-application.

Step 5: After building the application, you exit the container.

Step 6: Commit your changes to a new image.

You can use the container ID or name of the application to commit the changes.

Step 7: Finally run your custom image with the following command.

_Note: As much as this is an interactive way of containerizing an application. It is highly recommended to use a Dockerfile to containerize an application.
_

DEV Community: joy

Creating Parametrized builds using Jenkins

Introduction

Prerequisites

Step 1: Once Jenkins is installed, open it in a web browser using http://localhost:8080 and log in with the admin password.

Step 2: In the Jenkins dashboard, click Create Job, enter a name for your job, and select the Freestyle project option.

Step 3: After naming the job, go to the Configure tab to set up the parameterized build. Jenkins offers eight types of parameters, but for this tutorial, we’ll focus on String and Choice parameters. Start by creating a String parameter named Stage with a default value of Build.

Step 4 : Next, add a Choice parameter named Env with three values: Development, Staging, and Production.

Step 5: After adding the parameters, navigate to the Build section and click Add build step.

Step 6: Select Execute shell and enter commands that reference the Stage and Env parameters. For example we are using this in the build as shown in the previous:

Step 7: Once done, save the job. You will be redirected to the job homepage. Click Build with Parameters to see the input fields and run the build.

Step 8: Select a value for Env (Development, Staging, or Production) as displayed above and trigger the build. After the build completes, click the build number to see the results. Select Console Output to view detailed information about the build execution as shown below.

Conclusion

Load balancing with Docker Swarm & Nginx

Prerequisites

Step 1: Start with creating a folder where your application will run and initialize Docker swarm. docker swarm init

Step 2: Create a Docker service with the name of your application, replicas needed ports, and image needed. We will use alpine as the choice of image. docker service create --name yourappname --replicas 2 -p 8080:80 httpd:alpine

Step 3: Configure nginx at the ‘’/etc/nginx/sites-available/default’’ file location with the following variables.

Step 4: Save the configurations and restart the Nginx service.sudo systemctl restart nginx

Step 5: Go to the load balancing service using http://localhost or the IP address of your device. The screenshot displays that the site is actively working.

Conclusion

Set up an Automation script with Ansible

Prerequisites

Step 1: After installing Ansible, we create a directory where we store all the files needed.

Step 2: Create an inventory file (inventory.ini)in the directory and define our service. We add localhost as the testing environment.

Step 3: Create an Ansible playbook which is a yaml file. The Yaml file will define the tasks you would like to automate. In this scenario, we install and start an Apache Web server to localhost.

Step 4: We run the playbook using the ansible-playbook -i (inventory file) nameofyourplaybook.yaml.

Step 5:Your playbook should run successfully with the following output.

Conclusion

Send notifications to Slack using Jenkins

Introduction

Prerequisites

Step1 : We start by installing Jenkins and Java from the Jenkins official website.

Step 2: Go to the plugins section and click on available plugins. Install Slack notifications and restart Jenkins once done with installation.

Step 3: Go to https://api.slack.comcreate an (slackbot)application from scratch and add your workspace.

Step 4: Once the app is created, we click on OAuth and permissions and add go to the bot token scopes.

Step 5: Go to the Jenkins Dashboard and click on manage Jenkins + credentials.Click on the global domains where we add your Slack credentials.

Step 6: Click on manage Jenkins then configure systems. Scroll to the bottom where Slack exists and add the Slack workspace name and Slackbot credentials created.

Step 7: Once the values are added, apply and save the changes and test the connection for the Slack bot.

Step 8: Go to the Jenkins dashboard and click on a new item; name it what you wish and click the pipeline option.

Step 9: Go to the advanced project options; add a pipeline script. You can modify the text message in the slackSend value.

Step 10: Save and apply the changes. Once done, you customize and build the pipeline message and it shows up in your selected Slack channel.

Conclusion.

Deploying flask app to Kubernetes using Minikube

Introduction

Prerequisites

Step 1:Creating a Dockerfile with the following:

Step 2:Creating a docker-compose yaml file with the following:

Step 3: Run Docker Compose Commands.

Step 4: Load the Docker Image to Minikube.

Step 5: Create a Kubernetes Deployments file.

Step 6: Apply the deployment file to Minikube.

Step 7: Create a service file that exposes the flask application.

Step 8: Apply the service in minikube.

Step 9: Access the service.

Step 10: Stopping and deleting the Minikube cluster.

Conclusion

Containerizing your Go application using Docker

Introduction

Prerequisites

What is Docker?

Step 1:Cd into the directory that contains your code and libraries.

Step 2:Install the necessary build tools.

Step 3: Copy and install go dependencies for your application.

Step 4 : Run and build the Go application using docker build -o name-of-your-application.

Step 5: After building the application, you exit the container.

Step 6: Commit your changes to a new image.

Step 7: Finally run your custom image with the following command.

Conclusion

Containerizing your Go application by using Docker

Introduction

Prerequisites

What is Docker?

Step 1:Cd into the directory that contains your code and libraries.

Step 2:Install the necessary build tools.

Step 3: Copy and install go dependencies for your application.

Step 4 : Run and build the Go application using docker build -o name-of-your-application.

Step 5: After building the application, you exit the container.

Step 6: Commit your changes to a new image.

Step 7: Finally run your custom image with the following command.

Step 1: Start with creating a folder where your application will run and initialize Docker swarm. `docker swarm init`

Step 2: Create a Docker service with the name of your application, replicas needed ports, and image needed. We will use alpine as the choice of image. `docker service create --name yourappname --replicas 2 -p 8080:80 httpd:alpine`

Step 4: Save the configurations and restart the Nginx service.`sudo systemctl restart nginx`