DEV Community: Rohit Kumar

Setting up Jenkins Server and an Application Server Running Maven Application using Jenkinsfiles and GitHub Webhook

Rohit Kumar — Wed, 03 May 2023 15:46:06 +0000

Jenkins is a popular open-source automation tool that can be used to automate the entire software delivery process. In this documentation, we will be discussing how to set up a Jenkins server and an application server running a Maven application using Jenkinsfiles. Additionally, we will cover how to create a GitHub webhook to trigger automatic builds.

Prerequisites:

A server to install Jenkins and the application server.
Java JDK installed on the server.
Maven installed on the server.
A GitHub account with a repository to build.

Step 1: Install Jenkins on the Server

Ubuntu:

sudo apt update
sudo apt install openjdk-8-jdk -y
wget -q -O - <https://pkg.jenkins.io/debian-stable/jenkins.io.key> | sudo apt-key add -
sudo sh -c 'echo deb <https://pkg.jenkins.io/debian-stable> binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt update
sudo apt install jenkins -y

Start Jenkins service: sudo systemctl start jenkins

Step 2: Install Required Plugins

Plugins are software components that provide additional functionality to the core system. Jenkins plugins can be installed and configured through the Jenkins web interface, and they can add new features or modify existing ones, such as build triggers, source code management, reporting, and notifications. Plugins in Jenkins are essentially Java Archive (JAR) files that contain code that extends Jenkins. They are designed to be modular, so you can choose which plugins to install based on your specific needs.

Go to Jenkins -> Manage Jenkins -> Manage Plugins -> Available.

Maven Integration plugin:
Git plugin
Pipeline plugin
GitHub plugin

Step 3: Set up the Application Server

Tomcat is like a chef who specializes in serving up Java web applications to hungry internet users. It's a powerful and flexible tool that can take the raw ingredients of your Java application and turn them into a delicious, fully cooked website.

Just like a chef needs a kitchen to work in, Tomcat needs a server to run on. Once it's fired up, it can take in your Java web application and start serving it up to users who request it. It's a bit like a waiter, who takes orders from customers and brings them their food - except in this case, the customers are internet browsers, and the food is your website.

But Tomcat isn't just a simple waiter. It's more like a gourmet chef who can customize each order to suit the customer's tastes. It can handle all sorts of requests, from basic HTML pages to complex Java applications, and it can even handle multiple requests at once, just like a busy restaurant.

So, if you want to serve up a delicious Java web application to the world, Tomcat is the chef you need in your kitchen. It's fast, flexible, and always ready to cook up something amazing.

Install the application server, such as Tomcat, on the server where Jenkins is installed. Here we will be using Tomcat.

Install Tomcat:

sudo apt-get update
sudo apt-get install tomcat8 -y

Configure Tomcat user by setting up a new user with the appropriate permissions to access the server. Edit the Tomcat configuration file with the following:
Add the following lines before the line:
```
sudo nano /etc/tomcat8/tomcat-users.xml
```

```
<role rolename="manager-gui"/>
<user username="tomcat" password="password" roles="manager-gui"/>

```

Restart Tomcat: sudo systemctl restart tomcat8

Step 6: Create a Jenkinsfile

Jenkinsfile is a powerful tool used in the Jenkins automation server to define the entire build process of a project. It provides a declarative and programmatic way of defining the build pipeline, enabling the entire process to be versioned, reviewed, and tested just like any other codebase.

Jenkinsfile allows for the automation of the entire build process, from code compilation to the delivery of the final product. With Jenkinsfile, developers can define every stage of the pipeline, including the build, test, and deployment phases, as well as any custom stages that are specific to their project.

This level of automation can significantly reduce the time and effort required to build and deploy complex applications, as well as ensure consistency across all deployments. Jenkinsfile is also designed to be highly customizable, with a wide range of plugins and integrations available to extend its functionality and tailor it to specific project requirements. To create a Jenkinsfile, follow these steps:

In the root directory of your GitHub repository, create a new file named "Jenkinsfile".
Open the file in a text editor and add the following script:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Checkout the code from the GitHub repository
                git url: '<https://github.com/yourusername/yourrepository.git>'

                // Build the Maven project
                sh 'mvn clean package'

                // Archive the artifact
                archiveArtifacts artifacts: 'target/*.war'
            }
        }
        stage('Deploy') {
            steps {
                // Copy the artifact to the application server
                sshPublisher(
                    continueOnError: false,
                    failOnError: true,
                    publishers: [
                        sshPublisherDesc(
                            configName: 'yourserver',
                            transfers: [
                               sshTransfer(
                                    cleanRemote: false,
                                    excludes: '',
                                    execCommand: '',
                                    execTimeout: 120000,
                                    flatten: false,
                                    makeEmptyDirs: false,
                                    noDefaultExcludes: false,
                                    patternSeparator: '[, ]+',
                                    remoteDirectory: '/usr/share/tomcat8/webapps/',
                                    remoteDirectorySDF: false,
                                    removePrefix: '',
                                    sourceFiles: 'target/*.war'
                                )
                            ]
                        )
                    ]
                )
            }
        }
    }
}

The script defines a two-stage pipeline: Build and Deploy. In the Build stage, the code is checked out from the GitHub repository, the Maven project is built, and the artifact is archived. In the Deploy stage, the artifact is copied to the application server using the SSH plugin.

Note: Make sure to replace 'yourusername' and 'yourrepository' with your GitHub username and repository name, respectively. Also, replace '/usr/share/tomcat8/webapps/' with the path to the webapps directory on your application server.

Step 7: Set up GitHub Webhook

GitHub webhook is a feature of the GitHub platform that allows for the automatic triggering of events when certain actions are performed on a GitHub repository. It enables developers to automate their development workflow, increasing productivity and efficiency.

GitHub webhook works by sending HTTP requests to a URL configured to receive these requests whenever an event occurs in a GitHub repository. These events can include push notifications, pull requests, and issue comments, among others. When the webhook receives an event, it triggers a set of actions, such as running tests, deploying code, or sending notifications.

GitHub webhook can be integrated with a wide range of third-party tools and services, allowing developers to automate almost any aspect of their development workflow. For example, it can be used to trigger a build in Jenkins or another continuous integration tool, or to automatically deploy code to a production server. To trigger the Jenkins job automatically when changes are pushed to the GitHub repository, set up a GitHub webhook. To do this, follow these steps:

Go to the repository page on GitHub and select "Settings" -> "Webhooks" -> "Add webhook".
Enter the Payload URL of your Jenkins server followed by "/github-webhook/" (e.g., http://yourjenkinsserver.com/github-webhook/).
Select "application/json" as the content type and choose "Let me select individual events".
Check the "Push" and "Pull Request" events.
Click "Add webhook" to save the configuration.

That's it! Now, every time changes are pushed to the GitHub repository, the Jenkins job will be triggered automatically, and the application will be built and deployed to the application server.

Streamline Your Software Delivery with Jenkins: A Comprehensive Guide to CI/CD Pipelines

Rohit Kumar — Sat, 22 Apr 2023 06:01:42 +0000

In today's fast-paced software development world, delivering high-quality software quickly and efficiently is essential. Continuous Integration/Continuous Deployment (CI/CD) is a software development practice that helps teams automate the build, test, and deployment process, ensuring that software changes are thoroughly tested and deployed to production with minimal manual effort. Among the many tools available for implementing CI/CD pipelines, Jenkins stands out as one of the most popular and powerful options. In this blog post, we will explore the benefits of using Jenkins for CI/CD and provide a comprehensive guide to setting up an effective CI/CD pipeline using Jenkins.

Why Jenkins for CI/CD?

Jenkins is an open-source automation server that provides a wide range of features for implementing CI/CD pipelines. Here are some of the reasons why Jenkins is a popular choice for many development teams:

1. Flexibility and Extensibility: Jenkins offers a large ecosystem of plugins that can be used to integrate with various tools and services, making it highly flexible and extensible. This allows teams to customize their CI/CD pipeline to suit their specific needs and integrate with their existing tools and processes.

2. Ease of Use: Jenkins provides a user-friendly web-based interface for managing the pipeline, making it easy to configure and manage pipeline stages, steps, and dependencies. Jenkins also supports pipeline-as-code, allowing teams to define the pipeline configuration as code in a version control system, which can be easily reviewed, versioned, and shared.

3. Scalability and Distributed Builds: Jenkins supports distributed builds, allowing teams to scale their build and test processes across multiple agents, reducing the overall build time and increasing throughput. This makes Jenkins suitable for large-scale enterprise applications with complex build and test requirements.

4. Active Community and Support: Jenkins has a large and active community of users and contributors, providing a wealth of resources, documentation, and support options. This makes it easy to find help, troubleshoot issues, and stay updated with the latest features and best practices.

5. Integration with DevOps Practices: Jenkins is well-integrated with DevOps practices, such as version control, automated testing, and deployment automation. This makes it an ideal choice for organizations that are adopting DevOps principles and practices to improve their software delivery processes.

Now that we have discussed the benefits of using Jenkins for CI/CD, let's dive into the step-by-step guide to setting up a CI/CD pipeline using Jenkins.

Step 1: Install and Configure Jenkins

The first step in setting up a CI/CD pipeline using Jenkins is to install and configure Jenkins on a server or a cloud-based virtual machine. Jenkins can be installed on a variety of operating systems, including Windows, Linux, and macOS, and it can also be deployed as a Docker container. Once Jenkins is installed, you can access the web-based interface to configure basic settings, such as security, authentication, and plugins.

Step 2: Create a Jenkins Job

In Jenkins, a job represents a single unit of work in the pipeline, such as building, testing, or deploying the software. To create a Jenkins job, you can use the web-based interface or define the job configuration as code using the Jenkinsfile, which is a domain-specific language for defining pipelines. A Jenkins job typically consists of multiple stages, each representing a step in the CI/CD process, such as building, testing, and deploying the software.

Step 3: Define Pipeline Stages

The next step is to define the stages of the CI/CD pipeline in the Jenkins job. A pipeline stage represents a logical step in the software delivery process, such as building the software, running tests, and deploying to production. Each stage can have multiple steps, which are individual tasks that are executed sequentially. For example, a typical CI/CD pipeline may consist of stages such as "Build", "Test", "Deploy to Staging", and "Deploy to Production". Within each stage, you can configure the necessary steps, such as running a build script, executing tests, and deploying to the appropriate environment.

Step 4: Configure Source Code Integration

To enable continuous integration, you need to configure source code integration in your Jenkins job. This involves setting up a source code repository, such as Git or SVN, and configuring Jenkins to automatically trigger a build whenever changes are pushed to the repository. This allows you to automatically build and test the software whenever changes are made to the source code, ensuring that any issues are caught early in the development process.

Step 5: Implement Automated Testing

Automated testing is a crucial part of the CI/CD process, as it helps ensure that the software is thoroughly tested before it is deployed to production. Jenkins provides integration with various testing frameworks and tools, allowing you to automate the execution of unit tests, integration tests, and other types of tests as part of your CI/CD pipeline. You can configure the necessary testing steps within the appropriate stages of your pipeline, and set up notifications or alerts for test failures, so that any issues can be quickly addressed.

Step 6: Implement Deployment Automation

Deploying software to different environments, such as staging and production, can be a complex process that involves multiple steps, such as building and packaging the software, deploying it to the appropriate environment, and performing post-deployment tasks. Jenkins provides integration with various deployment tools and platforms, allowing you to automate the deployment process as part of your CI/CD pipeline. You can configure the necessary deployment steps, such as deploying to staging for further testing, and then deploying to production once all tests pass.

Step 7: Monitor and Manage the Pipeline

Monitoring and managing the CI/CD pipeline is an important part of ensuring smooth and efficient software delivery. Jenkins provides a rich set of monitoring and management features, such as visualizing the pipeline status, tracking the progress of builds and deployments, and managing pipeline artifacts. You can configure notifications and alerts to be sent to relevant team members or stakeholders, and use the web-based interface to manage the pipeline and troubleshoot any issues that may arise.

Step 8: Continuous Improvement

CI/CD is a continuous process, and it's important to continuously review and improve your pipeline to ensure that it remains effective and efficient. You can monitor and analyze the performance of your pipeline, such as build times, test coverage, and deployment success rates, and use this data to identify areas for improvement. You can also collect feedback from team members and stakeholders, and use it to make adjustments to your pipeline to better meet the needs of your development process.

Conclusion

Implementing a CI/CD pipeline using Jenkins can greatly streamline your software delivery process, allowing you to catch and fix issues early in the development cycle, and ensure that high-quality software is deployed to production with minimal manual effort. By following the step-by-step guide provided in this article, you can set up an effective CI/CD pipeline using Jenkins and enjoy the benefits of faster, more efficient, and more reliable software delivery.

Are you safe on internet?

Rohit Kumar — Tue, 04 Apr 2023 04:30:43 +0000

In today's era almost everything has been digitized, from sending messages to your loved ones to sending money to others. If you'll look at bigger picture, you'll find that everything is related to "data", which needs to be protected at any cost. Whether this data is at rest or being transited, it always should be authorized and should reach to the person for which it is intended to be sent. The personal information that we are going to talk about in this blog is also a piece of data that needs to be protected. Personal information of an individual is termed as PII (Personal Identifiable Information).

With the widespread use of the internet, social media, and e-commerce, our personal data is constantly at risk of being exposed or exploited by the hackers. This rise of technology also unveiled the rise of hackers that wants your data badly. It's yours as well as the organization's (to whom you are sharing your data) responsibility to protect it at any cost. As an individual here are some tips for securing your data from unauthorized access:

Use strong and unique passwords: You should create strong and unique passwords for each of your online accounts is essential to protect your personal information. Avoid using the same password for multiple accounts, as this can make it easier for cyber-criminals to access your information. Always use combination of uppercase and lowercase letters, numbers, and special characters to create strong passwords that are really hard to guess. Having a password with the name of your own could also lead to security breach, so its always recommended to not have passwords with your name in it, instead try having complex one.

Use password manager: Previously I explained how you can secure your online accounts, but remembering all the unique passwords can be hectic to anybody. So it's always preferable to use a password manager to store your passwords, this will save your unique passwords locally or in cloud. Some of the password managers are google password manager, bitwarden, 1Password, lastPassword, etc. Using a password add a security level to all of your passwords, which helps you secure your online accounts. Your online accounts always hold some private information regarding you, which could lead anyone being a victim of blackmailing or Cyberbullying. Be aware!

Enable two-factor authentication: Two-factor authentication provides an additional layer of security to your online accounts. It requires you to provide a second form of identification, such as a code sent to your phone, in addition to your password. This is the best method for securing your accounts since it authenticates users in person with the help of devices that you own. This extra layer security not only safeguard your online account information, but also helps you maintain your privacy against widespread internet. There are certain tools on internet which helps you securing your accounts, like Google Authenticator. Many social media accounts now provide two-factor authentication, you just have to enable them. Don't forget to enable them.

Be cautious of fishing scams: Phishing scams are a common form of cybercrime that can cause significant harm to individuals and organizations. Phishing scams typically involve the use of fraudulent emails, text messages, or other communications that appear to be from a legitimate source, such as a bank, government agency, or popular website. One of the most effective ways to protect yourself from phishing scams is to be cautious of any unsolicited emails or messages that ask for personal info. Another important step is to carefully review the sender's email address or phone number. Phishing scams often use fake or impersonated email addresses or phone numbers that are similar to legitimate ones but contain subtle differences. For example, a scam email may appear to be from "PayPal" but the email address may be "pay-pal.com" instead of "paypal.com".

Keep your software up to date: It is very important to remember that your software, which is installed in your device sometimes become a door for hackers to hack your system and steal your data. Software updates often include security patches that fix vulnerabilities and protect against known threats, as well as performance improvements and new features. Outdated software can cause you a great damage, since a hacker can inject malwares into your outdated software and then can access your whole system. Here are some tips to help you keep your software up to date:

Enable automatic updates
check for updates regularly
Download software updates from trusted sources only.
Restart your computer after installing updates.
```
   Beware of malwares!
```

Use a Virtual Private Network (VPN): VPNs create a secure and encrypted connection between your device and the internet, making it difficult for hackers, advertisers, or other third parties to intercept your data. It also hides your IP address, which is your unique identifier on the internet. By masking your IP address, VPNs help protect your online privacy and prevent advertisers and other third parties from tracking your online activities. Summing up VPN is best way to protect your personal data when you're online. By encrypting your internet traffic and hiding your IP address, VPNs help protect your online privacy and prevent third parties from intercepting or tracking your online activities.

Conclusion

In conclusion, protecting personal information online is a crucial aspect of staying safe in the digital age. As we increasingly rely on technology to manage our lives, it's important to be aware of the risks and take proactive steps to protect ourselves. It's also important to be mindful of the types of information we share online and who we share it with. Whether we're posting on social media, filling out online forms, or making purchases, we should always consider the potential risks and benefits of sharing our personal information.

Overall, protecting personal information online requires a combination of awareness, caution, and proactive steps. By taking these steps, we can help ensure that our personal information remains secure and that we can continue to enjoy the benefits of technology without compromising our privacy or security.

DEV Community: Rohit Kumar

Setting up Jenkins Server and an Application Server Running Maven Application using Jenkinsfiles and GitHub Webhook

Streamline Your Software Delivery with Jenkins: A Comprehensive Guide to CI/CD Pipelines

Why Jenkins for CI/CD?

Step 1: Install and Configure Jenkins

Step 2: Create a Jenkins Job

Step 3: Define Pipeline Stages

Step 4: Configure Source Code Integration

Step 5: Implement Automated Testing

Step 6: Implement Deployment Automation

Step 7: Monitor and Manage the Pipeline

Step 8: Continuous Improvement

Conclusion

Are you safe on internet?

Conclusion

Thank You!