DEV Community: Saeed H

How to Deploy a Containerized App on AWS Using Jenkins

Saeed H — Mon, 21 Aug 2023 17:56:32 +0000

In this project we are going to build on the multi-branch pipeline we set up in the previous project( see here https://shorturl.at/cuCJL). So the main focus for this article will be the deployment stage. Our objective is to connect to a remote server (EC2 Server) via from Jenkins using a SSH Agent and execute docker commands to create a container that runs an application.

Prerequisites:

AWS account with EC2 instance.
Docker Hub account with Docker image.

Server 1: Jenkins Setup

Launch an EC2 instance for Jenkins (Server 1). we have already set up a Jenkins server in the previous tutorial. See the link above.

Server 2: EC2 Instance Setup

Launch another EC2 instance for your application (Server 2) Create a new key pair and store it in a secure and accessible location on your computer. I have chosen .pem format as I am using Linux.

SSH into the server using the private key and install Docker:

   sudo yum update
   sudo yum install docker.io

Start Docker service:

   sudo systemctl start docker
   sudo systemctl enable docker

Add ec2-user to docker group to be able to execute commands:

   sudo usermod -aG docker $USER

Log out and log back for it to take effect.

Jenkins Configuration

Install SSH Agent plugin.

Configure SSH agent in Jenkins:

Inside credentials for multi-branch

Go to "Manage Jenkins" > "Manage Credentials" > "Global credentials" > "Add Credentials".
Choose "SSH Username with private key".

Give it an ID, enter the username (ec2-user), paste the private key downloaded earlier (for server 2).

Add SSH Agent credentials to the Jenkins file:

Jenkins has a cool feature that will generate the syntax needed for any plugin. Inside the Multi-branch pipeline go to 'Pipeline Syntax'

Choose the 'sshagent: SSH Agent', choose 'ec2-user' and generate.

Now, lets paste the generated syntax in to our Jenkins file and add our logic.

stage("deploy") {

            steps {
                script {
                    echo 'Deploying docker image to EC2'
                    def dockerCmd = "docker run -p 8080:8080 -d shersi32/myapp:1"
                sshagent(['ec2-server']) {
                  sh "ssh -o StrictHostKeyChecking=no ec2-user@54.175.82.44 ${dockerCmd}"
                    }
                }
            }

A few points about out the Jenkins file:

We created a variable for the docker run command to make things easier.
The "-o StrictHostKeyChecking=no" command suppresses pop ups (basically questions that may prevent the commands from executing)
Finally, there is no need for 'docker login' since we have logged in already (see above)

Save the Jenkins file.

Configure the Firewall on Server 2 (EC2)
Add an inbound rule for server 2 to allow SSH access from the Jenkins server.

Now lets see it in action

Commit your code changes to the Git repository.
Trigger the Jenkins pipeline manually
Jenkins will build your Docker image, push it to Docker Hub.
Then for the deploy stage, Jenkins will SSH in to the EC2 Server, pull the image from Docker Hub and start the container.

Here is the stage view of the pipeline:

And the logs for the 'deploy' stage:

Now lets check out the EC2 server:

And we did it! There is the container up and running!

All that's left now is to access our application using a browser. we just need the the public IP address and the port.
So, for us it is 54.175.82.44:3080.

And there it is, Brilliant!

So, That's all from me for now. I hope this blog is useful!

_Feel free to contact me with any feedback/questions/suggestions. _

How to set-up a Multi-Branch Pipeline on Jenkins

Saeed H — Sun, 13 Aug 2023 11:45:29 +0000

A multi-branch pipeline is a concept that automatically sets up Jenkins pipelines based on Git branches. It discovers new branches in GitHub (or any other SCM) and creates a pipeline for that branch. Once a new pipeline is set up, Jenkins uses the Jenkins file in that branch for build stages.

In this article we'll be going through the steps to set up a multi-branch pipeline for a basic Java/Maven App.

Step 1: Install and Configure Jenkins

If you haven't already, install Jenkins on your server or local machine following the official installation guide: https://www.jenkins.io/doc/book/installing/
After installation, open Jenkins in your web browser (http://localhost:8080 by default).

Step 2: Install Required Plugins

Click on "Manage Jenkins" in the left sidebar.

Select "Manage Plugins."

Navigate to the "Available" tab.
Search for and install the following plugins if they're not already installed:
- GitHub Integration: Allows Jenkins to interact with GitHub repositories.
- Pipeline Maven Integration: Allows Jenkins to work with Maven projects.

Step 3: Create a New Multi-Branch Pipeline

Click on "New Item" in the left sidebar.

Enter a name for your pipeline (e.g., "Multi-Branch Pipeline").
Choose "Multibranch Pipeline" as the project type and click "OK."

Step 4: Configure Source Code Management

In the "Branch Sources" section, click "Add Source" and select "GitHub."

Click on "GitHub" to configure the source details.
Provide your GitHub credentials or a personal access token (recommended for security).
Select the GitHub repository where your Java Maven project is hosted.

Specify the behavior for discovering branches. You can click on 'add' then choose 'filter by name(with regular expression'. In this case, we will choose the wildcard option to discover branches from the repo.

Click "Save" to save the configuration.

Step 5: Configure Jenkinsfile

In your GitHub repository, create a file named "Jenkinsfile" (without quotes) in the root directory. This file defines your pipeline.

Here's an example Jenkinsfile for a basic Java Maven project:

This Jenkinsfile defines three stages: Checkout, Build, and Test. It checks out the code from the repository, builds the Maven project, and runs tests.

Step 6: Run the Multi-Branch Pipeline

Back in Jenkins, you should see your multi-branch pipeline project.
Jenkins will automatically detect branches in your GitHub repository and create pipeline instances for each branch.
Click on a specific branch to see the pipeline runs and their status.
To manually trigger a pipeline run, click "Run" on the specific branch.

Tips:

Keep your Maven project's pom.xml file in the repository to manage project dependencies and configuration.
Make sure your Maven project has appropriate unit tests.
Regularly update Jenkins and its plugins for security and new features.
Use a version control system (like Git) for your codebase.
Secure your credentials using Jenkins' credentials plugin and avoid hardcoding sensitive information in your Jenkinsfile.

Conclusion:

So, there you have it we have set up a multi-branch pipeline for our Java Maven app on Jenkins, which will automatically build and test your project across different branches. Customize the pipeline stages and steps according to your project's needs, and you'll have a powerful and automated CI/CD process in place.

Stay tuned as we'll take this further in the new future and go a little bit deeper.

# Setting Up and Configuring a Server with a Bash Script

Saeed H — Wed, 12 Jul 2023 07:17:54 +0000

As a beginner, understanding how to set up and configure a server can be quite scary. However, with the help of a simple Bash script, you can automate this process and make it more accessible. In this blog article, we will walk you through the steps to create a Bash script that sets up and configures a server using a YAML configuration file. Let's get cracking!

Prerequisites

Before we begin, make sure you have the following:

Basic understanding of the Bash scripting language.
Access to a terminal or command line interface.

Getting Started

To create our script, follow these steps:

Open a text editor and create a new file. Let's name it script.sh.
Start the script by adding the shebang line, which specifies the interpreter to use:

   #!/bin/bash

Add a description to the script to help users understand its purpose:

   echo "setup and config server"

Define a variable to hold the name of the configuration file:

   file_name=config.yaml

Check if the config directory exists:

   if [ -d "config" ]
   then

If the config directory exists, display a message stating that its contents are being read:

     echo "reading config directory contents"
     config_files=$(ls config)
   else

If the config directory does not exist, display a message stating that it will be created:

     echo "config dir not found. creating one"
     mkdir config
   fi

Display a message indicating that the config.yaml file will be used for configuration:

   echo "using file $file_name to config it"

Finally, display a list of all the configuration files found in the config directory:

   echo "here are all the config files: $config_files"

That's it! You have created a basic Bash script that sets up and configures a server.

Next we'll look at how to actually put it in to action!

Using the Script

To use the script, follow these steps:

Open a terminal or command line interface.
Navigate to the directory where the script.sh file is located.
Make the script executable by running the following command:

   chmod +x script.sh

This part is key! Many beginners over look the importance of permissions.

Execute the script by running the following command:

   ./script.sh

The script will handle the setup and configuration of the server for you. It will check if the config directory exists and create it if necessary. Then, it will use the config.yaml file to configure the server. Finally, it will display a list of all the configuration files found in the config directory.

Conclusion

So let's recap, we have covered the process of creating a simple Bash script to set up and configure a server. By automating these tasks, you can simplify the server setup process, even as a beginner. Remember to customize the configuration according to your needs, and feel free to enhance the script as you gain more experience.

Hope you enjoyed reading!

A Beginners Guide to Shell Scripts

Saeed H — Fri, 09 Jun 2023 14:33:28 +0000

Introduction:
Shell scripting is an essential skill for DevOps engineers, allowing them to automate tasks, streamline processes, and improve efficiency. In this blog post, I'll provide a step-by-step guide for creating effective shell scripts from scratch. Utilizing diagrams, images, and practical examples, you will gain a comprehensive understanding of the shell scripting, enabling you to create powerful automation solutions.

1. Understanding Shell Scripting:
Shell scripting entails writing a sequence of commands in a plain text file, executable by the shell (command-line interpreter). As a DevOps engineer, you will primarily work with the Bash shell, a widely used scripting language. Mastering shell scripting empowers you to automate repetitive tasks and optimize workflows, driving operational efficiency and productivity.

2. Setting Up the Environment:
To start your journey into shell scripting, make sure you have a Unix-like operating system, such as Linux or macOS. These systems typically come pre-installed with a default shell, such as Bash. You can check the shell environment by using the command echo $SHELL in your terminal. Also, choose a text editor suited to your preferences and comfort level, such as Vim, Emacs, or Visual Studio Code.

3. Developing Your First Shell Script:
Let's create a simple yet significant shell script that outputs "Hello, World!" to the terminal. Follow these steps:

Step 1: Launch your chosen text editor and create a new file. Assign a descriptive name to the file, ensuring it carries the .sh extension, e.g., hello.sh.

Step 2: Begin your script with a shebang line, specifying the interpreter. For Bash scripts, the shebang line is #!/bin/bash.

Step 3: Provide a concise comment that describes the script's purpose and functionality, fostering better understanding and maintainability. For instance:

#!/bin/bash
# This script prints "Hello, World!" to the terminal.

Step 4: Proceed to write the script code. In this instance, a single line utilizing the echo command is sufficient to display the desired message:

#!/bin/bash
# This script prints "Hello, World!" to the terminal.

echo "Hello, World!"

4. Now Let's Execute and Test Your Shell Script:
To execute your shell script, follow these steps:

Step 1: Grant execution permissions to the script by using the command chmod +x hello.sh. This command allows the script to be executed.

Step 2: Execute the script by invoking ./hello.sh in your terminal. Observe the output "Hello, World!"

5. Let's Take Your Shell Script to The Next Level:
Now that you have created your first shell script, let's explore ways to enhance its functionality.

Accepting User Input: To make it more interactive, prompt the user for input within your script. For example, modify the script to request the user's name and personalize the greeting:

#!/bin/bash
# This script prompts the user for their name and prints a personalized greeting.

echo "What is your name?"
read name
echo "Hello, $name!"

Utilizing Variables: Leverage variables within your script to store and manipulate data. Enhance the previous script by storing the greeting message in a variable:

#!/bin/bash
# This script prompts the user for their name and prints a personalized greeting.

echo "What is your name?"
read name
g

reeting="Hello, $name!"
echo $greeting

Conditional Statements and Loops: Shell scripts support conditional statements (if-else) and loops (for, while), allowing for more a sophisticated control flow. Consider the following example, using a loop to greet the user multiple times:

#!/bin/bash
# This script prompts the user for their name and prints a personalized greeting five times.

echo "What is your name?"
read name

for i in {1..5}
do
  echo "Hello, $name! ($i)"
done

6. Conclusion:
Congratulations on acquiring the foundational knowledge for creating shell scripts. By starting with a simple "Hello, World!" script and then exploring techniques for script enhancement, you are now equipped to pursue advanced automation endeavors. Shell scripting empowers DevOps engineers to streamline operations, optimize workflows, and achieve significant productivity gains. Dedicate time to practice, experiment, and exploit the extensive capabilities of shell scripting, furthering your professional growth and proficiency.

Shell Scripting Explained

Saeed H — Tue, 06 Jun 2023 09:08:36 +0000

What is it?

Shell scripting is a powerful tool used in the world of Tech. It allows users to automate tasks and run several commands at once, making it an essential skill for system administrators, DevOps engineers, and software developers.

Benefits

One of the main benefits of shell scripting is its ability to simplify complex processes. With shell scripting, users can automate repetitive tasks, create custom commands, keep history of configurations, and even schedule scripts to run at specific times. This can save time and increase efficiency, especially when working with large amounts of data or complex systems.

Real World Uses

In the real world, shell scripting is used in a variety of scenarios. For example, system administrators use shell scripts to manage servers, automate backups, and perform maintenance tasks. DevOps engineers use shell scripting to deploy applications, manage cloud infrastructure, and automate testing. Software developers use shell scripting to build and package applications, manage dependencies, and automate build processes.

Wrapping up

Finally, shell scripting as you can see is an essential skill for anyone working in the world of Tech. Its ability to automate tasks and simplify complex processes makes it a valuable tool in a variety of real-world scenarios. In the following blogs, we will explore in detail how to write effective shell scripts and explore some common use cases.