DEV Community: Khalif AL Mahmud

Step-by-Step Guide to Building a Robust CI/CD Pipeline for Java Projects on AWS Linux with Git, Jenkins, Maven, & Tomcat

Khalif AL Mahmud — Sun, 19 Jan 2025 03:42:09 +0000

Continuous Integration and Continuous Deployment (CI/CD) pipelines have become critical in software development for delivering reliable, efficient, and automated workflows. In this blog, we’ll explore the process of building a robust CI/CD pipeline leveraging Git, Jenkins, Maven, and Tomcat, divided into three comprehensive steps.

Step 1: Setting Up Essential Tools and Environments

1.1 Process to Create EC2 Instances and Connect via SSH

Log in to AWS : Access the AWS Management Console

Navigate to EC2 Dashboard : In the Services menu, select EC2 under Compute.

Launch Instance

Click on Launch Instance.

Name and Tags: Assign a name to your instance (e.g., "Jenkins-Server").

Application and OS Images (Amazon Machine Image): Choose Amazon Linux 2 AMI (HVM), SSD Volume Type.

Instance Type: Select t2.micro (eligible for free tier).

Key Pair (Login)
- Create a new key pair or select an existing one.
- If creating new, download the .pem file and store it securely; you'll need it to access your instance.
Network Settings: Create a new security group with the following inbound rules:
- SSH (port 22): Allows secure shell access.
- HTTP (port 80): Enables web traffic.
- Custom TCP (port 8080): Required for Jenkins & tomcat access.
Configure Storage: The default storage configuration is typically sufficient.

Launch: Review all settings and click Launch Instance.

Verify Instance Status

Return to the EC2 Dashboard.
Ensure your instance's Instance State is running.

Set Key Permissions

Open your terminal.
Modify the permissions of your key pair file to ensure it's not publicly viewable:

chmod 400 /path/to/DEV_OPS_KEY.pem

Retrieve Public IP

In the EC2 Dashboard, select your instance.
Note the Public IPv4 address listed in the instance details.

Establish SSH Connection

Use the following command, replacing /path/to/your-key-pair.pem with the path to your key pair file and ec2-user@your-public-ip with the appropriate username and IP address:

ssh -i /path/to/your-key-pair.pem ec2-user@your-public-ip

For example:

ssh -i DEV_OPS_KEY.pem ec2-user@65.2.57.151

1.2 Process to Install Java

Jenkins requires Java to run. Follow these steps to install Java 17:

# Switch to the root user  
sudo su -

# Update all packages to the latest version
yum update -y   

# Install Amazon Corretto 17 (Java 17)
yum install java-17-amazon-corretto -y 

# Check the installed Java version
java -version

Expected output:

1.3 Process to Install Jenkins

# Download and add the Jenkins repository configuration  
wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo  

# Import the Jenkins repository GPG key for package verification  
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key  

# Install Jenkins  
yum install jenkins -y  

# Check the current status of the Jenkins service
systemctl status jenkins  

# Enable Jenkins to start on system boot 
systemctl enable jenkins  

# Start the Jenkins service 
systemctl start jenkins

Access Jenkins Web Interface

Open a browser and navigate to:

http://<public-ip-address>:8080

Replace <public-ip-address> with your EC2 instance's public IP.

Retrieve the initial admin password:

cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins setup page.

[!WARNING]

If Can’t access username or password, forgot these credentials after installing Jenkins

Other Necessary Commands

# Stop the Jenkins service if running  
systemctl stop jenkins  

# Check Jenkins service logs to debug any issues 
journalctl -u jenkins -b  

# Display the installed Jenkins version (if Jenkins is in the system PATH)
jenkins --version

Expected output:

1.4 Process to Install Git

# Install Git from the default Amazon Linux repository
yum install git -y    

# Verify the installed Git version
git --version          

# Find the path of the Git binary
which git

Configure Git in Jenkins:

Install the GitHub plugin:

Navigate to Manage Jenkins > Plugins > Available Plugins tab.
Search for GitHub and install it.

Configure Git Path

Navigate to Manage Jenkins > Tools tab.

1.5 Process to Install Maven

Go to the /opt directory, which is typically used for storing applications on Linux.

cd /opt

Visit maven.apache.org to get the latest Maven tar.gz file. Alternatively, use wget to download directly:

wget https://dlcdn.apache.org/maven/maven-3/3.9.9/binaries/apache-maven-3.9.9-bin.tar.gz

Extract the Archive:

tar -xvzf apache-maven-3.9.9-bin.tar.gz
mv apache-maven-3.9.9 maven

Verify Maven Installation

Before proceeding with setting up the environment variables, let's verify that Maven is correctly installed. Navigate to the Maven folder and check the version:

cd maven
./bin/mvn -v

This will show the Maven version, Java version, and operating system details.

Note: Running mvn -v will only work if you're inside the /opt/maven/ folder. For access it globally we have to set environment variable.

Configure Environment Variables

Now that Maven is installed, we need to set up environment variables (JAVA_HOME, M2_HOME, and M2) to make Maven accessible globally on the system.

Find the Java Home Path If you don't already know where Java is installed, you can use the find command to locate it:

find / -name java-17*

Once you find the Java installation path, note it down. For example, the path might be /usr/lib/jvm/java-17-openjdk

Set Environment Variables

Edit the .bash_profile file to add the necessary environment variables.

nano ~/.bash_profile

Add the following lines at the end of the file, replacing the paths with the correct ones for your setup:

# `JAVA_HOME` points to the Java installation directory.
JAVA_HOME=/usr/lib/jvm/java-17-amazon-corretto.x86_64

#`M2_HOME` points to the directory where Maven is installed.
M2_HOME=/opt/maven

#`M2` points to the Maven `bin` directory, which contains the `mvn` command.
M2=/opt/maven/bin

#We update the `PATH` variable to include `Maven` and `Java` locations, ensuring that Maven can be accessed globally.
PATH=$PATH:$HOME/bin:$JAVA_HOME:$M2_HOME:$M2

Save the file and exit the editor.
Reload the profile to apply the changes:

source ~/.bash_profile

Verify that Maven is now globally accessible by running:

mvn -v

This should show Maven's version along with the Java version.

Configure Maven in Jenkins:

Global Path Configure Maven in Jenkins

Navigate to Manage Jenkins > Tools.
Add a new Maven installation by providing the name and path.

Install the Maven Integration plugin

Go to Manage Jenkins > Plugins > Available tab.
Search for Maven Integration and install it.

1.6 Process to Install Tomcat

Download Apache Tomcat

Navigate to the

  /opt

directory:

  cd /opt

Download the Apache Tomcat package:

  wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.98/bin/apache-tomcat-9.0.98.tar.gz

Extract the package:

  tar -xvzf apache-tomcat-9.0.98.tar.gz
  mv apache-tomcat-9.0.98 tomcat

Set Permissions

Grant execute permissions to startup.sh and shutdown.sh

  chmod +x /opt/tomcat/bin/startup.sh
  chmod +x /opt/tomcat/bin/shutdown.sh

Create Startup and Shutdown Links

Create symbolic links for easier management:

  ln -s /opt/tomcat/bin/startup.sh /usr/local/bin/tomcatup
  ln -s /opt/tomcat/bin/shutdown.sh /usr/local/bin/tomcatdown

Start Tomcat:

  tomcatup

Access the Tomcat Application

Open a browser and navigate to:

  http://<Public_IP>:8080

Enable Browser Login

Locate the

  context.xml

files:

  find / -name context.xml

Edit both /opt/tomcat/webapps/host-manager/META-INF/context.xml and /opt/tomcat/webapps/manager/META-INF/context.xml files
Comment the <Value ClassName> field in the context.xml files located under the webapps directory.

/opt/tomcat/webapps/host-manager/META-INF/context.xml

/opt/tomcat/webapps/manager/META-INF/context.xml

Restart Tomcat:

  tomcatdown
  tomcatup

Configure User Access

Edit the

  tomcat-users.xml

file:

  cd /opt/tomcat/conf

Add the following user configurations:

  <role rolename="manager-gui"/>
  <role rolename="manager-script"/>
  <role rolename="manager-jmx"/>
  <role rolename="manager-status"/>
  <user username="admin" password="admin" roles="manager-gui,manager-script,manager-jmx,manager-status"/>
  <user username="deployer" password="deployer" roles="manager-script"/>
  <user username="tomcat" password="s3cret" roles="manager-gui"/>

Restart Tomcat:

  tomcatdown
  tomcatup

Verify Login

Access the Tomcat application in your browser:

  http://<Public_IP>:8080 OR http://<Public_IP>:8090

Change Default Port ( OPTIONAL )

By default, Tomcat runs on port 8080, which may conflict with other applications like Jenkins. To change the port:

Edit the

  server.xml

file:

  cd /opt/tomcat/conf

Locate and update the

  <Connector port>

field to 8090 in

  server.xml

Restart Tomcat for changes to take effect:

  tomcatdown
  tomcatup

Verify access on the new port:

  http://<Public_IP>:8090

Configure Necessary Settings in Jenkins for Tomcat:

Install the "Deploy to Container" plugin in Jenkins:

Go to Manage Jenkins > Plugins > Available tab.
Search for Deploy to Container and install it.

Add Tomcat Credentials in Jenkins:

Navigate to Manage Jenkins > Credentials > System > Global credentials (unrestricted).
Click Add Credentials.
Choose Username and password as the credential type.
Enter the Tomcat manager username and password (as configured in conf/tomcat-users.xml).

Save the credentials for use in Jenkins jobs.

Step 2: Setting Up the CI/CD Pipeline Environment

1. Create the First EC2 Instance
Follow 1.1 Process to Create EC2 Instances and Connect via SSH to launch an EC2 instance and connect to it securely. Ensure the instance is properly configured with the required security group rules (e.g., open ports for SSH and Jenkins).

2. Install Java
Complete 1.2 Process to Install Java to install the Java Development Kit (JDK) on your EC2 instance. Java is required for running Jenkins and other tools in the pipeline.

3. Install Jenkins
Follow 1.3 Process to Install Jenkins to set up Jenkins on the EC2 instance. Jenkins is the core automation server that will orchestrate the CI/CD pipeline. Ensure Jenkins is up and running, and accessible through its web interface.

4. Install Git
Complete 1.4 Process to Install Git to install Git on the instance. Git will be used to manage source code repositories and enable Jenkins to pull the latest code for building and deployment.

5. Install Maven
Proceed with 1.5 Process to Install Maven to set up Maven on the EC2 instance. Maven will handle the build and dependency management for the applications deployed in the CI/CD pipeline.

Step 3: Setting Up the Deployment Server

1. Create the Second EC2 Instance

Refer to 1.1 Process to Create EC2 Instances and Connect via SSH to launch a new EC2 instance.
Ensure the security group is configured to allow traffic on ports required for Tomcat (e.g., port 8080 for HTTP).

2. Install Java

Complete 1.2 Process to Install Java on the new EC2 instance to set up the Java Development Kit (JDK).
Java is required to run Tomcat, which is a Java-based application server.

3. Install Tomcat

Follow 1.6 Process to Install Tomcat to set up Apache Tomcat on the EC2 instance.
Tomcat will act as the deployment server, hosting the applications built and managed by the CI/CD pipeline.

Step 4: Configuring Jenkins to Build and Deploy the Project

In this step, we will configure Jenkins to automate the build and deployment process for a Java project using Maven and Tomcat. Follow the detailed steps below:

1. Log in to Jenkins

Access the Jenkins web interface using the URL: http://<Jenkins-Server-IP>:8080.
Use the credentials retrieved during Jenkins setup to log in.

2. Create a New Maven Project

Click on New Item in Jenkins.
Enter a name for the project (e.g., Java-App-Build).
Select Maven Project as the project type and click OK.

3. Configure Git Repository

In the Source Code Management section, select Git.
Enter the Git repository URL (e.g., https://github.com/devops-vsc/hello-java).

Add Git credentials if the repository is private.

4. Set Up Build Triggers

Select Poll SCM as the build trigger.
In the schedule field, enter

  * * * * *

to poll the repository every minute for changes.

Why? This ensures Jenkins automatically triggers a build whenever there are changes in the repository.

5. Configure Build Steps

In the Build section, specify the Root POM (e.g., pom.xml).
In Goals and options, enter

  clean install

Why clean install?
- clean: Removes any previous build files to ensure a fresh build.
- install: Compiles the code, runs tests, and packages the project as a .war file for deployment.

6. Add Post-Build Action

Select Deploy war/ear to a container from the Post-Build Actions dropdown.

7. Configure Deployment to Tomcat

In the WAR/EAR files field, enter

  **/*.war

Why? This ensures Jenkins deploys all .war files generated during the build.
- Under Containers, select Tomcat 9.x Remote.
- Provide the following details:
Credentials: Select the credentials added in ( 1.6 Process to Install Tomcat > Add Tomcat Credentials in Jenkins)
Tomcat URL: Enter the URL and port where Tomcat is running (e.g., http://<Tomcat-Server-IP>:8080).

8. Save and Build the Job

Click Apply and then Save.
Trigger a build by clicking Build Now.
Jenkins will:

Pull the latest code from the Git repository.
Build the project using Maven.
Deploy the .war artifact to the Tomcat server.

9. Verify Deployment

Open a browser and navigate to the Tomcat server URL (e.g., http://<Tomcat-Server-IP>:8080/<project-name>).
Confirm that the application is successfully deployed and running.

With this setup, Jenkins automates the entire CI/CD process, ensuring code changes are built, tested, and deployed seamlessly to the Tomcat server.

Integrating Maven with Jenkins: A Step-by-Step Guide

Khalif AL Mahmud — Tue, 14 Jan 2025 06:51:49 +0000

This guide walks you through integrating Maven with Jenkins to automate the build process for Java projects. We'll cover everything from setting up Maven on the Jenkins server to building a Java project hosted on GitHub.

1. Setting Up Maven on the Jenkins Server

Download and Install Maven

Switch to the root user to ensure you have the necessary permissions.

sudo su -

Go to the /opt directory, which is typically used for storing applications on Linux.

cd /opt

Visit maven.apache.org to get the latest Maven tar.gz file. Alternatively, use wget to download directly:

wget https://dlcdn.apache.org/maven/maven-3/3.9.9/binaries/apache-maven-3.9.9-bin.tar.gz

Extract the Archive:

tar -xvzf apache-maven-3.9.9-bin.tar.gz
mv apache-maven-3.9.9 maven

Verify Maven Installation

Before proceeding with setting up the environment variables, let's verify that Maven is correctly installed. Navigate to the Maven folder and check the version:

cd maven
./bin/mvn -v

This will show the Maven version, Java version, and operating system details.

Note: Running mvn -v will only work if you're inside the /opt/maven/ folder. For access it globally we have to set environment variable.

Configure Environment Variables

Now that Maven is installed, we need to set up environment variables (JAVA_HOME, M2_HOME, and M2) to make Maven accessible globally on the system.

Find the Java Home Path If you don't already know where Java is installed, you can use the find command to locate it:

find / -name java-17*

Once you find the Java installation path, note it down. For example, the path might be /usr/lib/jvm/java-17-openjdk

Set Environment Variables

=> Edit the .bash_profile file to add the necessary environment variables.

nano ~/.bash_profile

=> Add the following lines at the end of the file, replacing the paths with the correct ones for your setup:

JAVA_HOME=/usr/lib/jvm/java-17-amazon-corretto.x86_64
M2_HOME=/opt/maven
M2=/opt/maven/bin
PATH=$PATH:$HOME/bin:$JAVA_HOME:$M2_HOME:$M2

JAVA_HOME points to the Java installation directory.
M2_HOME points to the directory where Maven is installed.
M2 points to the Maven bin directory, which contains the mvn command.
We update the PATH variable to include Maven and Java locations, ensuring that Maven can be accessed globally.

=> Save the file and exit the editor.

=> Reload the profile to apply the changes:

source ~/.bash_profile

=> Verify that Maven is now globally accessible by running:

mvn -v

This should show Maven's version along with the Java version.

2. Install the Maven Plugin in Jenkins

Log in to Jenkins:
Open your Jenkins dashboard in a web browser.
Install the Maven Plugin:
- Navigate to Manage Jenkins > Manage Plugins.
- Under the "Available" tab, search for "Maven Integration Plugin."
- Select and install the plugin, then restart Jenkins if required.
Configure Maven and Java:
- Go to Manage Jenkins > Global Tool Configuration.
- Scroll to the "Maven" section and add a new Maven installation: Provide a name (e.g., Maven3.8) and Set the Maven home directory to /opt/maven.
- Scroll to the "JDK" section and set the Java home directory (e.g., /usr/lib/jvm/java-11-openjdk).

3. Build a Java Project with Jenkins

Now that Maven is configured in Jenkins, we can set up a Jenkins job to build a Java project.

Create a New Maven Project
- From the Jenkins dashboard, click on New Item.
- Select Maven Project and give it a name (e.g., "JavaBuild").
- Click OK.
Configure Git Repository and Build Goals
- Under the Source Code Management section, select Git and provide the repository URL: https://github.com/devops-vsc/hello-java.git
- Under the Build section, add the following goal: clean install

clean: Cleans the project by deleting the target directory.
install: Compiles the code, runs tests, and installs the artifacts in the local Maven repository.

Save the job configuration
- Build the Project Click on Build Now to trigger the build process. Jenkins will fetch the code from the Git repository, compile it, and run the tests. If successful, the build will complete with a "SUCCESS" status.

Integrating Maven with Jenkins simplifies the build and deployment process for Java projects. By following this guide, you’ve set up Maven, configured Jenkins, and built a Java project from a GitHub repository. This setup provides a solid foundation for automating your software development workflows.

Can’t access username or password, forgot these credentials after installing Jenkins

Khalif AL Mahmud — Sun, 12 Jan 2025 05:23:02 +0000

Jenkins is a powerful automation server widely used for continuous integration and delivery (CI/CD). However, users often encounter login-related issues, especially during their first interaction with the system or after a system restart. If Jenkins is now asking for a username and password and you're unsure where to find them, this guide will help you understand why this happens and how to regain access.

Understanding Jenkins Authentication

First-Time Login with Key

During the initial installation of Jenkins, the system uses a key-based authentication mechanism. Typically, an initial admin password is generated and stored in a file within Jenkins' home directory. This password is required to complete the initial setup and configure an admin user.

Subsequent Logins with Username and Password

Once the initial setup is complete, Jenkins requires a username and password for login. If you skipped creating an admin account or forgot the credentials, you’ll need to retrieve or reset them to regain access.

Where to Find Jenkins Credentials

1. Initial Admin Password (First-Time Setup)
The initial admin password is stored in the following locations:

Linux Systems: /var/lib/jenkins/secrets/initialAdminPassword
Windows Systems: %JENKINS_HOME%\secrets\initialAdminPassword

To retrieve the password:

Open the specified file using a text editor or command-line tool.
- Linux: cat /var/lib/jenkins/secrets/initialAdminPassword
- Windows: Open the file in Notepad or any text editor.
Use the retrieved password along with the username admin to log in.

2. Custom Admin Credentials (After Setup)
If you created an admin account during the setup process, use the username and password you configured. If these are forgotten, proceed to the credential reset steps.

Steps to Resolve Login Issues

Accessing the Initial Admin Password If the setup process is incomplete:

Locate the initialAdminPassword file as described above.
Log in with admin as the username and the retrieved password.

Resetting Credentials If you’ve already set up an admin user but can’t remember the credentials, here are two ways to reset them:

Option 1: Reset Password via Configuration Files

Stop the Jenkins Service:
- On Linux: sudo systemctl stop jenkins
- On Windows: Stop the service from the Services application.
Edit the config.xml File:
- Navigate to Jenkins' home directory.
- Open config.xml and locate the <useSecurity>true</useSecurity> tag.
- Change it to <useSecurity>false</useSecurity> or remove the tag.
Restart Jenkins:
- On Linux: sudo systemctl start jenkins
- On Windows: Restart the service from the Services application.
Log in without credentials. Re-enable security and set a new admin user.

Option 2: Create a New Admin User via CLI or Script Console

Open Jenkins CLI or Script Console.
Run the following Groovy script to create a new admin user:

jenkins.model.Jenkins.instance.securityRealm.createAccount('newAdmin', 'newPassword')

Best Practices for Credential Management

Secure Storage: Store Jenkins credentials securely in a password manager.
Regular Backups: Backup Jenkins configuration files and the home directory regularly.
External Authentication: Consider integrating Jenkins with external authentication systems like LDAP or SSO to simplify user management.

Jenkins login issues can be frustrating, but understanding the authentication process and knowing how to retrieve or reset credentials can help you quickly regain access. By following the steps outlined in this guide, you can overcome these challenges and maintain a secure, efficient CI/CD environment.

Need further assistance? Feel free to share your questions or experiences in the comments below!

Streamlining CI/CD: A Complete Guide to Installing Jenkins on AWS EC2

Khalif AL Mahmud — Sat, 11 Jan 2025 14:56:49 +0000

Setting up Jenkins on an AWS EC2 instance allows you to automate your software development processes efficiently. This guide provides a detailed, step-by-step approach to launching an EC2 instance, installing Jenkins, and configuring it for your CI/CD needs.

Prerequisites

AWS Account: Ensure you have an active AWS account. If not, sign up here.
Basic Knowledge: Familiarity with AWS services and command-line operations is beneficial.

Step 1 — Launch an EC2 Instance

Log in to AWS: Access the AWS Management Console.
Navigate to EC2 Dashboard:
- In the Services menu, select EC2 under Compute.
Launch Instance:
- Click on Launch Instance.
- Name and Tags: Assign a name to your instance (e.g., "Jenkins-Server").
- Application and OS Images (Amazon Machine Image): Choose Amazon Linux 2 AMI (HVM), SSD Volume Type.
- Instance Type: Select t2.micro (eligible for free tier).
- Key Pair (Login):
  - Create a new key pair or select an existing one.
  - If creating new, download the .pem file and store it securely; you'll need it to access your instance.
- Network Settings:
  - Create a new security group with the following inbound rules:
    - SSH (port 22): Allows secure shell access.
    - HTTP (port 80): Enables web traffic.
    - Custom TCP (port 8080): Required for Jenkins access.
- Configure Storage: The default storage configuration is typically sufficient.
- Launch: Review all settings and click Launch Instance.
Verify Instance Status:
- Return to the EC2 Dashboard.
- Ensure your instance's Instance State is running.

Step 2 — Connect to Your EC2 Instance via SSH

Set Key Permissions:
- Open your terminal.
- Modify the permissions of your key pair file to ensure it's not publicly viewable:

chmod 400 /path/to/your-key-pair.pem

Retrieve Public IP:
- In the EC2 Dashboard, select your instance.
- Note the Public IPv4 address listed in the instance details.
Establish SSH Connection:
- Use the following command, replacing /path/to/your-key-pair.pem with the path to your key pair file and ec2-user@your-public-ip with the appropriate username and IP address:

ssh -i /path/to/your-key-pair.pem ec2-user@your-public-ip

For example:

ssh -i ~/.ssh/jenkins-key.pem ec2-user@54.123.45.67

Step 3 — Install Java

Jenkins requires Java to run. Follow these steps to install Java 17:

Update Packages:

sudo yum update -y

Install Java 17:

sudo yum install java-17-amazon-corretto -y

Verify Installation:

java -version

Expected output:

openjdk version "17.0.x" 2023-xx-xx
OpenJDK Runtime Environment Corretto-17.0.x.x.x (build 17.0.x+xx)
OpenJDK 64-Bit Server VM Corretto-17.0.x.x.x (build 17.0.x+xx, mixed mode)

Step 4 — Install Jenkins

Add Jenkins Repository:

sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo

Import Jenkins GPG Key:

sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

Install Jenkins:

sudo yum install jenkins -y

Enable Jenkins Service:

sudo systemctl enable jenkins

Start Jenkins Service:

sudo systemctl start jenkins

Check Jenkins Status:

sudo systemctl status jenkins

Ensure the output indicates that Jenkins is active (running).

Step 5 — Access Jenkins Web Interface

Open a browser and navigate to:

http://<public-ip-address>:8080

Replace <public-ip-address> with your EC2 instance's public IP.

Retrieve the initial admin password:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins setup page.

Install suggested plugins and create your admin user.

Step 6 — Create a Jenkins Job

From the Jenkins dashboard, click New Item.
Name the job (e.g., "Hello-World") and select Freestyle Project.
Scroll down to the Build Environment section and check "Delete workspace before build starts."
Under Build Steps, click Add build step > Execute Shell, and enter:

echo "Hello, World!"

Save and click Build Now.
Check the console output to see "Hello, World!" printed.

Conclusion

Congratulations! You’ve successfully set up Jenkins on an AWS EC2 instance, accessed its web interface, and created a simple Jenkins job. Jenkins is a versatile tool that supports complex CI/CD workflows, making it invaluable for software development teams.

Feel free to explore plugins and additional configurations to tailor Jenkins to your project's needs.

Resolving SSH Authentication Errors on Mac: Using a .pem File

Khalif AL Mahmud — Thu, 09 Jan 2025 04:47:15 +0000

When attempting to connect to a remote server via SSH, you might encounter an error indicating that your client isn’t configured to use the correct private key. This typically happens when the server expects a private key for authentication, and your SSH setup isn’t pointing to the correct .pem file. Here's how to resolve this issue on a Mac.

Steps to Use the `.pem` File for SSH

1. Ensure You Have the `.pem` File

The private key file (e.g., my-key.pem) is essential for establishing a secure connection. This file should have been provided or downloaded from your cloud provider (like AWS) when setting up the server.

2. Set Proper Permissions for the `.pem` File

To protect your private key, it’s critical to restrict its permissions. Use the following command to set the appropriate permissions:

chmod 400 path/to/your-key.pem

This ensures that only your user account can read the file.

3. Connect to the Server Using the `.pem` File

When connecting via SSH, specify the .pem file using the -i flag:

ssh -i path/to/your-key.pem username@3.81.139.63

Replace path/to/your-key.pem with the actual path to your .pem file.
Replace username with the correct username for the server (e.g., ec2-user, ubuntu, or sakib).

4. Check SSH Configuration (Optional)

For convenience, you can create an SSH configuration file to simplify future connections:

Open or create the SSH config file:

nano ~/.ssh/config

Add the following configuration:

Host my-server
    HostName 3.81.139.63
    User sakib
    IdentityFile path/to/your-key.pem

Save and exit the file. Now, you can connect simply by typing:

ssh my-server

Troubleshooting Common Issues

Key Pair Mismatch

Ensure that the .pem file you are using matches the public key configured on the remote server. If the keys don’t match, you’ll encounter authentication errors.

Wrong Username

Some servers have specific default usernames based on their operating systems:

Ubuntu: ubuntu
Amazon Linux: ec2-user
CentOS: centos
Debian: admin or debian
RHEL: ec2-user

If you’re unsure, check the documentation of your cloud provider or contact the server administrator.

Check Server Logs (Advanced)

If you have access to server logs, they can provide insight into authentication failures. Check /var/log/auth.log (on Ubuntu/Debian) or /var/log/secure (on CentOS/RHEL).

An Introduction to DevOps Build Tools for Different Programming Languages

Khalif AL Mahmud — Thu, 02 Jan 2025 05:49:00 +0000

DevOps প্রক্রিয়া সফটওয়্যার উন্নয়ন এবং অপারেশন ব্যবস্থার মধ্যে সেতু হিসেবে কাজ করে। সফটওয়্যার তৈরি এবং ম্যানেজ করার জন্য বিভিন্ন ভাষায় বিভিন্ন ধরনের বিল্ড টুলস ব্যবহৃত হয়। এই ব্লগে আমরা কিছু জনপ্রিয় বিল্ড টুলস এবং তাদের ভূমিকা সম্পর্কে আলোচনা করব।

JavaScript (Node.js) / TypeScript

Npm: জাভাস্ক্রিপ্ট প্যাকেজ ম্যানেজার
Webpack: মডিউল বান্ডলার যা কোডকে অপটিমাইজ করে
Gulp: রিপিটিটিভ কাজগুলির জন্য টাস্ক রানার

PHP

Composer: পিএইচপি ডিপেনডেন্সি ম্যানেজার
Phing: পিএইচপি ভিত্তিক বিল্ড সিস্টেম যা Ant ব্যবহার করে

Java

Maven: একটি শক্তিশালী ডিপেনডেন্সি ম্যানেজমেন্ট এবং বিল্ড অটোমেশন টুল
Gradle: একটি দ্রুত এবং নমনীয় বিল্ড সিস্টেম
Ant: XML কনফিগারেশনের মাধ্যমে বিল্ড প্রক্রিয়া পরিচালনা

Python

Pip: প্যাকেজ ম্যানেজার যা পাইটন লাইব্রেরি ইনস্টল করতে ব্যবহৃত হয়
setuptools: পাইথন প্রোজেক্ট প্যাকেজিং এবং বিতরণ সরঞ্জাম
SCons: পাইথন ভিত্তিক সফটওয়্যার কনস্ট্রাকশন টুল

C# (.NET)

MSBuild: .NET অ্যাপ্লিকেশনের বিল্ড সিস্টেম
Visual Studio Build Tools: .NET প্রোজেক্টের জন্য IDE ভিত্তিক বিল্ড টুল

C/C++

Make: বিল্ড অটোমেশন টুল যা Makefile-এ নির্ধারিত থাকে
CMake: প্ল্যাটফর্মে নিরপেক্ষ বিল্ড সিস্টেম জেনারেটর
Ninja: একটি দ্রুত এবং ছোট বিল্ড সিস্টেম

Objective-C

Xcode Build: Objective-C এবং iOS/macOS অ্যাপ্লিকেশন বিল্ড সিস্টেম

Ruby

Rake: রুবি ভিত্তিক টাস্ক ম্যানেজমেন্ট টুল
Bundler: রুবি অ্যাপ্লিকেশন ডিপেনডেন্সি ম্যানেজার

Go

Go Build: গো ভাষার অফিসিয়াল বিল্ড টুল
Mage: গো ব্যবহার করে একটি মেকের মতো বিল্ড টুল

Rust

Cargo: Rust ভাষার বিল্ড সিস্টেম এবং প্যাকেজ ম্যানেজার

R

RStudio: R প্রোজেক্টের জন্য একটি IDE এবং বিল্ড টুল
Make: R প্রোজেক্টের জন্য সাধারণ বিল্ড টুল

Perl

Make: একটি সাধারণ বিল্ড অটোমেশন টুল
Perl Build: Perl মডিউল জন্য বিল্ড সিস্টেম

Swift

Xcode Build: iOS এবং macOS অ্যাপ্লিকেশন বিল্ড সিস্টেম
Swift Package Manager: Swift ভাষার জন্য প্যাকেজ ম্যানেজার

Kotlin

Gradle: Kotlin-এর জন্য বিল্ড অটোমেশন টুল
Maven: Java এবং Kotlin উভয়ের জন্য একটি শক্তিশালী বিল্ড টুল

Scala

SBT: Scala-এর জন্য একটি ইন্টারঅ্যাকটিভ বিল্ড টুল
Maven: Scala অ্যাপ্লিকেশন বিল্ড এবং ডিপেনডেন্সি ম্যানেজমেন্ট

Haskell

Cabal: Haskell ভাষার জন্য বিল্ড টুল
Stack: Haskell প্রোজেক্ট ম্যানেজার

Elixir

Mix: Elixir প্রোজেক্টের জন্য বিল্ড টুল

এছাড়াও, প্রতিটি প্রোগ্রামিং ভাষার জন্য নির্দিষ্ট বিল্ড টুলস রয়েছে যা ডেভেলপারদের জন্য গুরুত্বপূর্ণ। এই টুলগুলি বিল্ড প্রক্রিয়া সহজ এবং অটোমেটেড করার মাধ্যমে সফটওয়্যার ডেভেলপমেন্টকে আরও দক্ষ এবং দ্রুততর করে। DevOps প্রক্রিয়ার অংশ হিসেবে এই টুলসগুলি ব্যবহৃত হয় যা কোডের বিল্ড, টেস্ট এবং ডেপ্লয়মেন্ট প্রক্রিয়াগুলি ত্বরান্বিত করে।

Essential JavaScript Array Methods Every Developer Should Know

Khalif AL Mahmud — Fri, 08 Nov 2024 10:06:59 +0000

Do not modify the original array :

মেথড	রিটার্ন ভ্যালু	উদাহরণ	রিটার্নের ধরন	ব্যাখ্যা (Explanation)
map()	New array	`[1, 2, 3].map(x => x * 2)`	New array [2, 4, 6]	অ্যারের প্রতিটি এলিমেন্টের উপর ফাংশন প্রয়োগ করে নতুন অ্যারে তৈরি করে। (Applies a function to each element in the array and creates a new array.)
filter()	New array	`[1, 2, 3, 4].filter(x => x > 2)`	New array [3, 4]	একটি শর্ত অনুসারে এলিমেন্টগুলো ফিল্টার করে এবং নতুন অ্যারে রিটার্ন করে। (Filters elements based on a condition and returns a new array.)
concat()	New array	`[1, 2].concat([3, 4])`	New array [1, 2, 3, 4]	একাধিক অ্যারে যোগ করে নতুন অ্যারে রিটার্ন করে। (Joins multiple arrays and returns a new array.)
slice()	New array	`[1, 2, 3, 4].slice(1, 3)`	New array [2, 3]	নির্দিষ্ট ইন্ডেক্স থেকে কিছু এলিমেন্ট কপি করে নতুন অ্যারে রিটার্ন করে। (Copies specific elements based on indices to create a new array.)
join()	String	`[1, 2, 3].join('-')`	String '1-2-3'	অ্যারের সব এলিমেন্টকে একত্রে যোগ করে একটি স্ট্রিং রিটার্ন করে। (Joins all array elements into a string.)
reverse()	New array	`[1, 2, 3].reverse()`	New array [3, 2, 1]	অ্যারের এলিমেন্টগুলো উল্টে নতুন অ্যারে রিটার্ন করে। (Reverses the elements of the array and returns a new array.)
includes()	Boolean	`[1, 2, 3].includes(2)`	true	অ্যারে মধ্যে একটি নির্দিষ্ট এলিমেন্ট রয়েছে কিনা তা চেক করে। (Checks if a specific element exists in the array.)
indexOf()	Number (Index)	`[1, 2, 3].indexOf(2)`	1	নির্দিষ্ট এলিমেন্টের প্রথম ইনডেক্স রিটার্ন করে। (Returns the first index of a specific element.)
find()	First matched element	`[1, 2, 3].find(x => x > 1)`	2	প্রথম মিল পাওয়া এলিমেন্টটি রিটার্ন করে। (Returns the first matching element.)
findIndex()	Number (Index)	`[1, 2, 3].findIndex(x => x > 1)`	1	প্রথম মিল পাওয়া এলিমেন্টের ইনডেক্স রিটার্ন করে। (Returns the index of the first matching element.)
flat()	New array	`[1, [2, 3], [4, 5]].flat()`	New array [1, 2, 3, 4, 5]	অ্যারের ভিতরের nested অ্যারেগুলিকে একত্রিত করে নতুন অ্যারে রিটার্ন করে। (Flattens nested arrays into a single array.)
flatMap()	New array	`[1, 2].flatMap(x => [x, x * 2])`	New array [1, 2, 2, 4]	প্রথমে map() প্রয়োগ করে তারপর ফ্ল্যাট করে। (Applies map() first, then flattens the result.)
sort()	New array	`[3, 1, 2].sort()`	New array [1, 2, 3]	অ্যারের এলিমেন্টগুলো সাজিয়ে দেয়। (Sorts the elements of the array.)
every()	Boolean	`[1, 2, 3].every(x => x > 0)`	true	সমস্ত এলিমেন্ট শর্ত পূর্ণ করলে true, অন্যথায় false রিটার্ন করে। (Returns true if all elements satisfy the condition; otherwise, false.)
some()	Boolean	`[1, 2, 3].some(x => x > 2)`	true	যদি কোনো এক বা একাধিক এলিমেন্ট শর্ত পূর্ণ করে, তবে true রিটার্ন করে। (Returns true if one or more elements satisfy the condition.)
reduce()	Single value (like number)	`[1, 2, 3].reduce((acc, x) => acc + x, 0)`	6	অ্যারের সকল এলিমেন্টকে একত্রিত করে একটি একক মান রিটার্ন করে। (Combines all elements into a single value.)
reduceRight()	Single value (like number)	`[1, 2, 3].reduceRight((acc, x) => acc + x, 0)`	6	reduce() এর মত তবে ডান থেকে বাম দিকে কাজ করে। (Similar to reduce(), but works from right to left.)

Modify the original array :

মেথড	রিটার্ন ভ্যালু	উদাহরণ	রিটার্নের ধরন	ব্যাখ্যা (Explanation)
push()	New length (number)	`[1, 2].push(3)`	New length 3	একটি এলিমেন্ট অ্যারে শেষে যোগ করে এবং অ্যারের নতুন লেন্থ রিটার্ন করে। (Adds an element at the end of the array and returns the new length.)
pop()	Removed element	`[1, 2, 3].pop()`	Removed element 3	অ্যারের শেষ থেকে একটি এলিমেন্ট মুছে ফেলে। (Removes the last element from the array.)
shift()	Removed element	`[1, 2, 3].shift()`	Removed element 1	অ্যারের প্রথম এলিমেন্ট মুছে ফেলে। (Removes the first element from the array.)
unshift()	New length (number)	`[1, 2].unshift(0)`	New length 3	একটি এলিমেন্ট অ্যারের প্রথমে যোগ করে এবং অ্যারের নতুন লেন্থ রিটার্ন করে। (Adds an element at the beginning of the array and returns the new length.)
splice()	Changed part (array)	`[1, 2, 3].splice(1, 1, 4)`	Changed array [2]	একটি নির্দিষ্ট ইনডেক্স থেকে এলিমেন্ট মুছে ফেলে এবং ঐ জায়গায় নতুন এলিমেন্ট যোগ করে। (Removes elements from a specific index and adds new elements.)
sort()	Changed array	`[3, 1, 2].sort()`	Changed array [1, 2, 3]	অ্যারের এলিমেন্টগুলো সাজিয়ে দেয়। (Sorts the elements of the array.)
fill()	Changed array	`[1, 2, 3].fill(0)`	Changed array [0, 0, 0]	অ্যারের সমস্ত এলিমেন্টকে একটি নির্দিষ্ট মান দিয়ে পূর্ণ করে। (Fills all elements of the array with a specific value.)
copyWithin()	Changed array	`[1, 2, 3, 4].copyWithin(0, 2)`	Changed array [3, 4, 3, 4]	অ্যারের একটি অংশকে অন্যত্র কপি করে। (Copies a portion of the array to another location within the same array.)
reverse()	Changed array	`[1, 2, 3].reverse()`	Changed array [3, 2, 1]	অ্যারের এলিমেন্টগুলো উল্টে দেয়, তবে এটি মূল অ্যারে পরিবর্তন করে। (Reverses the array elements, modifying the original array.)

Show the Last Commit of a GitHub Repository in Terminal Prompt

Khalif AL Mahmud — Sun, 27 Oct 2024 04:15:20 +0000

As developers, we often want quick access to recent Git activity, especially when switching between projects. With a few simple adjustments to your shell’s configuration, you can have your terminal automatically display the latest Git commit message and hash each time you open it within a Git repository. In this tutorial, we’ll set up a function to show the last commit in both Zsh and Bash.

Step 1: Edit Your Shell Configuration File

Depending on your shell, you’ll need to edit either the .zshrc (for Zsh) or .bashrc (for Bash) file. Follow these steps:

Open your shell configuration file:

nano ~/.zshrc   # for Zsh users
nano ~/.bashrc  # for Bash users

This will open the configuration file in your chosen text editor.

Step 2: Add a Function to Fetch the Last Commit

Next, add a custom function that will fetch and display the last commit message and hash from your Git history.

Copy and paste the following code snippet into your .zshrc or .bashrc file:

show_last_commit() {
  if [ -d .git ]; then
    echo "Last commit: $(git log -1 --pretty=format:'%h - %s (%cr)')"
  fi
}

Step 3: Run the Function When Your Terminal Starts

To execute the function every time you open a new terminal session, add the following line at the end of your .zshrc or .bashrc file:

show_last_commit

This line will call the show_last_commit function each time you start a new terminal session, displaying the last commit if you’re in a Git repository.

Step 4: Apply the Changes

Once you’ve added the function and set it to run on startup, save and close the file. Then, source your configuration file to apply the changes immediately:

source ~/.zshrc  # for Zsh users
source ~/.bashrc # for Bash users

Example Output

Now, when you navigate to a directory with Git initialized, you’ll see the last commit displayed automatically in your terminal:

Last commit: abc1234 - Fix layout issue on home page (3 hours ago)

If you’re not in a Git repository, the message won’t appear, keeping your prompt clean and relevant.

With just a few lines of code, you’ve now added a handy feature to your terminal! Not only does this display save you time, but it also keeps you informed about your project’s recent changes. Whether you’re using Zsh or Bash, this quick enhancement is a simple way to streamline your workflow.

Happy coding!

Simplifying Data Fetching in React with Axios and React Query in Next.js

Khalif AL Mahmud — Tue, 22 Oct 2024 09:23:37 +0000

React Query is a powerful library that simplifies data fetching, caching, and state management in React applications. When combined with Next.js, a popular server-side rendering framework for React, it becomes even more effective in handling CRUD operations. In this blog, we’ll explore how to use React Query with Next.js to perform Create, Read, Update, and Delete (CRUD) operations using Axios for data handling.

Assuming you have a new or existing Next.js project, install the required packages:

npm install axios react-query

Step 1: Creating the API Functions:

Create separate functions to handle CRUD operations using Axios. These functions will interact with your API server. For simplicity, we’ll create a fictional example of managing “todos.”

// utils/api.js
import axios from "axios";
const apiUrl = "https://api.example.com/todos";
export const fetchTodos = () => axios.get(apiUrl);
export const createTodo = (todo) => axios.post(apiUrl, todo);
export const updateTodo = (id, todo) => axios.put(`${apiUrl}/${id}`, todo);
export const deleteTodo = (id) => axios.delete(`${apiUrl}/${id}`);

Step 2: Setting up React Query:

In your Next.js application, create a react-query client and wrap your application with the QueryClientProvider.

// pages/_app.js
import { QueryClient, QueryClientProvider } from "react-query";
const queryClient = new QueryClient();

function MyApp({ Component, pageProps }) {
 return (
  <QueryClientProvider client={queryClient}>
   <Component {...pageProps} />
  </QueryClientProvider>
 );
}
export default MyApp;

Step 3: Fetching Todos using React Query:

In your component, use the useQuery hook provided by React Query to fetch and cache the todos.

// pages/index.js
import { useQuery } from "react-query";
import { fetchTodos } from "../utils/api";

function TodoList() {
 const { data: todos, isLoading, error } = useQuery("todos", fetchTodos);

 if (isLoading) return <div>Loading...</div>;

 if (error) return <div>Error: {error.message}</div>;

 return (
  <div>
   {todos.map((todo) => (
    <div key={todo.id}>{todo.title}</div>
   ))}
  </div>
 );
}

export default TodoList;

Step 4: Creating a New Todo:

Let’s add a form to create a new todo using the useMutation hook from React Query.

// pages/index.js
import { useQuery, useMutation } from "react-query";
import { fetchTodos, createTodo } from "../utils/api";

function TodoList() {
 // ... Same code as before ...

 const mutation = useMutation(createTodo, {
  onSuccess: () => {
   queryClient.invalidateQueries("todos");
  },
 });

 const handleAddTodo = (event) => {
  event.preventDefault();
  const formData = new FormData(event.target);
  const title = formData.get("title");
  mutation.mutate({ title });
 };

 return (
  <div>
   {todos.map((todo) => (
    <div key={todo.id}>{todo.title}</div>
   ))}

   <form onSubmit={handleAddTodo}>
    <input type="text" name="title" placeholder="Enter todo title" />
    <button type="submit">Add Todo</button>
   </form>
  </div>
 );
}

export default TodoList;

Step 5: Updating and Deleting Todos:

We’ll follow a similar approach for updating and deleting todos.

// pages/index.js
import { useQuery, useMutation } from "react-query";
import { fetchTodos, createTodo, updateTodo, deleteTodo } from "../utils/api";

function TodoList() {
 // ... Same code as before ...

 const updateMutation = useMutation(updateTodo, {
  onSuccess: () => {
   queryClient.invalidateQueries("todos");
  },
 });

 const deleteMutation = useMutation(deleteTodo, {
  onSuccess: () => {
   queryClient.invalidateQueries("todos");
  },
 });

 const handleUpdateTodo = (id, newTitle) => {
  updateMutation.mutate({ id, title: newTitle });
 };

 const handleDeleteTodo = (id) => {
  deleteMutation.mutate(id);
 };

 return (
  <div>
   {todos.map((todo) => (
    <div key={todo.id}>
     <input
      type="text"
      value={todo.title}
      onChange={(e) => handleUpdateTodo(todo.id, e.target.value)}
     />
     <button onClick={() => handleDeleteTodo(todo.id)}>Delete</button>
    </div>
   ))}

   <form onSubmit={handleAddTodo}>
    <input type="text" name="title" placeholder="Enter todo title" />
    <button type="submit">Add Todo</button>
   </form>
  </div>
 );
}

export default TodoList;

By integrating React Query with Next.js and Axios, we’ve successfully implemented CRUD operations for managing todos in our application. React Query’s powerful caching and data synchronization features make it an excellent choice for handling complex data scenarios. As you continue to build your application, remember to follow similar patterns for other data entities and actions as needed.

Happy coding!

A Comprehensive Guide with XHR, Fetch API, Axios and jQuery AJAX

Khalif AL Mahmud — Tue, 22 Oct 2024 09:11:41 +0000

In this blog post, we’ll explore four commonly used JavaScript APIs for making HTTP requests: Fetch API, Axios, and jQuery AJAX. We’ll provide short examples for each of these APIs to demonstrate how to perform CRUD (Create, Read, Update, Delete) operations.

1. XMLHttpRequest (XHR):

A traditional JavaScript API for making asynchronous HTTP requests in web browsers, allowing interaction with servers and handling data in formats like XML or JSON.

Create: Create new data using XMLHttpRequest with the POST method and send XML data to the server, and handle the response to access the created data.

const createData =
 "<user><name>John Doe</name><email>john@example.com</email></user>";

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://api.example.com/users", true);
xhr.setRequestHeader("Content-Type", "application/xml");

xhr.onload = function () {
 if (xhr.status >= 200 && xhr.status < 300) {
  console.log("User created successfully:", xhr.responseXML);
 } else {
  console.error("Error creating user:", xhr.status, xhr.statusText);
 }
};

xhr.onerror = function () {
 console.error("Error creating user:", xhr.status, xhr.statusText);
};

xhr.send(createData);

Read: Fetch data from the server using XMLHttpRequest with the GET method, and handle the response to access the retrieved data.

const xhr = new XMLHttpRequest();
xhr.open("GET", "https://api.example.com/users/123", true);

xhr.onload = function () {
 if (xhr.status >= 200 && xhr.status < 300) {
  console.log("User data:", xhr.responseXML);
 } else {
  console.error("Error fetching user data:", xhr.status, xhr.statusText);
 }
};

xhr.onerror = function () {
 console.error("Error fetching user data:", xhr.status, xhr.statusText);
};

xhr.send();

Update: Update existing data by using XMLHttpRequest with the PUT method and sending XML data to the server with modified information, and handle the response to access the updated data.

const updateData =
 "<user><name>Jane Smith</name><email>jane@example.com</email></user>";

const xhr = new XMLHttpRequest();
xhr.open("PUT", "https://api.example.com/users/123", true);
xhr.setRequestHeader("Content-Type", "application/xml");

xhr.onload = function () {
 if (xhr.status >= 200 && xhr.status < 300) {
  console.log("User updated successfully:", xhr.responseXML);
 } else {
  console.error("Error updating user:", xhr.status, xhr.statusText);
 }
};

xhr.onerror = function () {
 console.error("Error updating user:", xhr.status, xhr.statusText);
};

xhr.send(updateData);

Delete: Remove data from the server using XMLHttpRequest with the DELETE method, and confirm the successful deletion through the response.

const xhr = new XMLHttpRequest();
xhr.open("DELETE", "https://api.example.com/users/123", true);

xhr.onload = function () {
 if (xhr.status >= 200 && xhr.status < 300) {
  console.log("User deleted successfully.");
 } else {
  console.error("Error deleting user:", xhr.status, xhr.statusText);
 }
};

xhr.onerror = function () {
 console.error("Error deleting user:", xhr.status, xhr.statusText);
};

xhr.send();

2. Fetch API:

A modern native JavaScript API for making asynchronous HTTP requests in browsers, featuring a simpler and more standardized interface compared to XHR, widely recommended for modern applications.

Create: Use the fetch() function with the POST method to create new data by sending a JSON payload to the server.

const createData = {
 name: "John Doe",
 email: "john@example.com",
};

fetch("https://api.example.com/users", {
 method: "POST",
 headers: {
  "Content-Type": "application/json",
 },
 body: JSON.stringify(createData),
})
 .then((response) => response.json())
 .then((data) => {
  console.log("User created successfully:", data);
 })
 .catch((error) => {
  console.error("Error creating user:", error);
 });

Read: Fetch data using the fetch() function with the GET method, and handle the response as JSON to access the retrieved data.

fetch("https://api.example.com/users/123")
 .then((response) => response.json())
 .then((data) => {
  console.log("User data:", data);
 })
 .catch((error) => {
  console.error("Error fetching user data:", error);
 });

Update: Use the fetch() function with the PUT method to update existing data by sending a JSON payload to the server with modified information.

const updateData = {
 name: "Jane Smith",
 email: "jane@example.com",
};

fetch("https://api.example.com/users/123", {
 method: "PUT",
 headers: {
  "Content-Type": "application/json",
 },
 body: JSON.stringify(updateData),
})
 .then((response) => response.json())
 .then((data) => {
  console.log("User updated successfully:", data);
 })
 .catch((error) => {
  console.error("Error updating user:", error);
 });

Delete: Delete data from the server using the fetch() function with the DELETE method, which will remove the specified resource.

fetch("https://api.example.com/users/123", {
 method: "DELETE",
})
 .then((response) => {
  if (response.ok) {
   console.log("User deleted successfully.");
  } else {
   console.error("Error deleting user.");
  }
 })
 .catch((error) => {
  console.error("Error deleting user:", error);
 });

3. Axios:

A popular, lightweight JavaScript library for making HTTP requests, offering a promise-based API and features like request interception and JSON data handling.

Create: Employ axios.post() to create new data by sending a JSON payload to the server, and handle the response to access the created data.

const createData = {
 name: "John Doe",
 email: "john@example.com",
};

axios
 .post("https://api.example.com/users", createData)
 .then((response) => {
  console.log("User created successfully:", response.data);
 })
 .catch((error) => {
  console.error("Error creating user:", error);
 });

Read: Use axios.get() to fetch data from the server and handle the response to access the retrieved data.

axios
 .get("https://api.example.com/users/123")
 .then((response) => {
  console.log("User data:", response.data);
 })
 .catch((error) => {
  console.error("Error fetching user data:", error);
 });

Update: Use axios.put() to update existing data by sending a JSON payload to the server with modified information, and handle the response to access the updated data.

const updateData = {
 name: "Jane Smith",
 email: "jane@example.com",
};

axios
 .put("https://api.example.com/users/123", updateData)
 .then((response) => {
  console.log("User updated successfully:", response.data);
 })
 .catch((error) => {
  console.error("Error updating user:", error);
 });

Delete: Utilize axios.delete() to remove data from the server, and confirm the successful deletion through the response.

axios
 .delete("https://api.example.com/users/123")
 .then(() => {
  console.log("User deleted successfully.");
 })
 .catch((error) => {
  console.error("Error deleting user:", error);
 });

4. jQuery AJAX:

Part of the jQuery library, it simplifies asynchronous HTTP requests in web applications, providing an easy-to-use API for AJAX operations.

Create: Use $.ajax() with the POST method to create new data by sending a JSON payload to the server, and handle the response to access the created data.

const createData = {
 name: "John Doe",
 email: "john@example.com",
};

$.ajax({
 url: "https://api.example.com/users",
 method: "POST",
 contentType: "application/json",
 data: JSON.stringify(createData),
 success: function (data) {
  console.log("User created successfully:", data);
 },
 error: function (error) {
  console.error("Error creating user:", error);
 },
});

Read: Fetch data from the server using $.ajax() with the GET method, and handle the response to access the retrieved data.

$.ajax({
 url: "https://api.example.com/users/123",
 method: "GET",
 success: function (data) {
  console.log("User data:", data);
 },
 error: function (error) {
  console.error("Error fetching user data:", error);
 },
});

Update: Use $.ajax() with the PUT method to update existing data by sending a JSON payload to the server with modified information, and handle the response to access the updated data.

const updateData = {
 name: "Jane Smith",
 email: "jane@example.com",
};

$.ajax({
 url: "https://api.example.com/users/123",
 method: "PUT",
 contentType: "application/json",
 data: JSON.stringify(updateData),
 success: function (data) {
  console.log("User updated successfully:", data);
 },
 error: function (error) {
  console.error("Error updating user:", error);
 },
});

Delete: Use $.ajax() with the DELETE method to remove data from the server, and confirm the successful deletion through the response.

$.ajax({
 url: "https://api.example.com/users/123",
 method: "DELETE",
 success: function () {
  console.log("User deleted successfully.");
 },
 error: function (error) {
  console.error("Error deleting user:", error);
 },
});

Happy coding!

Setting Up Node.js and Yarn on Debian-based Distributions

Khalif AL Mahmud — Tue, 22 Oct 2024 09:01:39 +0000

In today’s rapidly evolving world of web development, having a robust and efficient development environment is crucial. In this blog post, we will walk you through the process of setting up Node.js and Yarn on Debian-based Distributions, empowering you to create and manage your JavaScript projects with ease. Node.js, a powerful runtime environment, coupled with Yarn, a dependable package manager, will streamline your workflow and enhance your productivity. So, let’s dive into the step-by-step guide and get started on the path to efficient development!

Step 1: Removing Node.js

To ensure a clean slate for our installation, let’s first remove any existing Node.js installations. Open up your terminal and execute the following command:

sudo apt remove nodejs

Step 2: Installing NVM (Node Version Manager)

NVM is a versatile tool that facilitates the management of different Node.js versions. Let’s proceed with its installation by entering the following command:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Step 3: Checking NVM Version

Verifying the successful installation of NVM is vital. Run the following command to ensure that NVM has been set up properly:

nvm --version

Step 4: Configuring Bash

To make NVM readily available every time you open a terminal, we need to configure the Bash shell. Let’s do that by adding the necessary line to the .bashrc file using the Nano text editor:

nano ~/.bashrc

Once the file is open, add the following line at the end:

source ~/.nvm/nvm.sh

Save the changes and exit Nano by pressing Ctrl + X, then Y, and finally Enter.

Step 5: Activating NVM

To activate NVM and set a specific version of Node.js as active, execute the following command:

source ~/.nvm/nvm.sh

Step 6: Installing Node.js

Now it’s time to install Node.js itself. As an example, we’ll install version 18.16.0, but feel free to use any version you prefer:

nvm install 18.16.0

Step 7: Setting the Default Node.js Version

Setting a default Node.js version can be handy. To do so, enter:

nvm alias default 18.16.0

Step 8: Checking Node.js and npm Versions

To double-check that Node.js has been installed correctly, verify its version:

node -v

Similarly, confirm the installed version of npm with:

npm -v

Step 9: Installing Yarn

Yarn, a swift and dependable package manager, can greatly enhance your development experience. Install it globally with the following command:

npm install -g yarn

Step 10: Verifying Yarn Installation

Ensure that Yarn has been installed successfully by checking its version:

yarn -v

Congratulations!
You’ve successfully set up Node.js and Yarn on your linux environment. With these powerful tools at your disposal, you’re now equipped to embark on your development journey. Whether you’re building intricate web applications or crafting elegant scripts, Node.js and Yarn will be your steadfast companions. Remember, if you encounter any hurdles or have questions along the way, the Node.js and Yarn communities are here to assist.

Shopify vs. WordPress: Key Features and Functionalities

Khalif AL Mahmud — Tue, 22 Oct 2024 08:57:39 +0000

When transitioning from WordPress to Shopify, it’s important to grasp how certain functionalities differ. While both platforms serve distinct purposes, many features can be adapted for a smooth experience. Here’s a breakdown of how Shopify handles various aspects compared to WordPress.

Custom Post Types and Content Organization
In WordPress, custom post types allow you to create unique content types. Shopify, however, doesn’t support custom post types. Instead, you can utilize Pages, Blog Posts, and Products to achieve similar results. For organizing your content, Shopify uses tags and collections instead of custom taxonomies, helping you categorize blog posts and pages effectively.

Utilizing Metafields
To extend the functionality of your Shopify store, you can leverage metafields. These allow you to add custom fields, including images, to collections or products. Apps like Metafields Guru or the Shopify Admin API can help you define and manage these fields easily.

Creating Reusable Content
While WordPress offers shortcodes for reusable content blocks, Shopify provides snippets. These snippets allow you to create reusable elements within your theme, streamlining your workflow.

Theme Customization
Just like WordPress, Shopify has a theme editor where you can customize settings. The settings_schema.json file allows you to control various aspects like layout, colors, and fonts, making it easy to tailor your store’s appearance.

Dynamic Behavior in Themes
Shopify does not have hooks, actions, or filters like WordPress. Instead, you can achieve dynamic behavior through JavaScript events or Liquid conditionals within your theme. This approach allows you to create interactive elements based on user actions.

Content Display with Liquid
WordPress uses WP Query for custom queries, whereas Shopify relies on Liquid filters and collections. You can filter products, collections, or pages based on specific criteria using Liquid, making content display highly customizable.

API Integration
Shopify offers its own GraphQL and REST API, similar to WordPress’s REST API. This functionality enables you to access store data, integrate external services, or build headless Shopify stores efficiently.

Multilingual Support
For multilingual capabilities, Shopify supports apps like Langify or Shopify Markets. While WordPress often utilizes plugins like WPML or Polylang, Shopify provides built-in features or app integrations to manage multiple languages.

Page Building Options
Unlike WordPress, which has native page builders like Elementor, Shopify provides sections and third-party apps such as Shogun or PageFly. These tools allow for a drag-and-drop page-building experience, enhancing your site’s design flexibility.

Extending Customer Data
You can extend customer data in Shopify using metafields or apps that add additional profile features. This is particularly useful for tailoring the shopping experience.

Scheduled Tasks
Shopify doesn’t natively support cron jobs like WordPress does. However, you can use Shopify scripts or integrate third-party apps to automate tasks such as inventory syncing or updates.

AJAX Functionality
Shopify supports AJAX for dynamic actions like adding products to the cart or filtering collections. This is similar to how WordPress employs AJAX for dynamic content loading without page reloads, improving user experience.

Conclusion
While Shopify and WordPress each have their strengths, understanding these differences can help you leverage Shopify’s features effectively. By utilizing metafields, Liquid, and third-party apps, you can create a robust and flexible online store that meets your unique needs. Whether you’re migrating from WordPress or starting fresh, knowing how to adapt your strategies will set you up for success in the Shopify ecosystem.

DEV Community: Khalif AL Mahmud

Step-by-Step Guide to Building a Robust CI/CD Pipeline for Java Projects on AWS Linux with Git, Jenkins, Maven, & Tomcat

Step 1: Setting Up Essential Tools and Environments

1.1 Process to Create EC2 Instances and Connect via SSH

Launch Instance

Verify Instance Status

Set Key Permissions

Retrieve Public IP

Establish SSH Connection

1.2 Process to Install Java

1.3 Process to Install Jenkins

1.4 Process to Install Git

Configure Git in Jenkins:

1.5 Process to Install Maven

Configure Environment Variables

Configure Maven in Jenkins:

1.6 Process to Install Tomcat

Download Apache Tomcat

Set Permissions

Create Startup and Shutdown Links

Access the Tomcat Application

Enable Browser Login

Configure User Access

Verify Login

Change Default Port ( OPTIONAL )

Configure Necessary Settings in Jenkins for Tomcat:

Step 2: Setting Up the CI/CD Pipeline Environment

Step 3: Setting Up the Deployment Server

Step 4: Configuring Jenkins to Build and Deploy the Project

Integrating Maven with Jenkins: A Step-by-Step Guide

1. Setting Up Maven on the Jenkins Server

Download and Install Maven

Verify Maven Installation

Configure Environment Variables

2. Install the Maven Plugin in Jenkins

3. Build a Java Project with Jenkins

Can’t access username or password, forgot these credentials after installing Jenkins

Understanding Jenkins Authentication

First-Time Login with Key

Subsequent Logins with Username and Password

Where to Find Jenkins Credentials

Steps to Resolve Login Issues

Option 1: Reset Password via Configuration Files

Option 2: Create a New Admin User via CLI or Script Console

Best Practices for Credential Management

Streamlining CI/CD: A Complete Guide to Installing Jenkins on AWS EC2

Table of Contents:

Prerequisites

Step 1 — Launch an EC2 Instance

Step 2 — Connect to Your EC2 Instance via SSH

Step 3 — Install Java

Step 4 — Install Jenkins

Step 5 — Access Jenkins Web Interface

Step 6 — Create a Jenkins Job

Conclusion

Resolving SSH Authentication Errors on Mac: Using a .pem File

Steps to Use the .pem File for SSH

1. Ensure You Have the .pem File

2. Set Proper Permissions for the .pem File

3. Connect to the Server Using the .pem File

4. Check SSH Configuration (Optional)

Troubleshooting Common Issues

Key Pair Mismatch

Wrong Username

Check Server Logs (Advanced)

An Introduction to DevOps Build Tools for Different Programming Languages

JavaScript (Node.js) / TypeScript

PHP

Java

Python

C# (.NET)

C/C++

Objective-C

Ruby

Go

Rust

R

Perl

Swift

Kotlin

Steps to Use the `.pem` File for SSH

1. Ensure You Have the `.pem` File

2. Set Proper Permissions for the `.pem` File

3. Connect to the Server Using the `.pem` File