DEV Community: Ansuman Satapathy

Deploying a Multi-Stage Docker Image to AWS EC2 using Docker Hub

Ansuman Satapathy — Sat, 27 Jul 2024 07:07:27 +0000

Hello, Guys! Hope you are doing alright. So, in this article I'll be sharing how to dockerize a Spring Boot application, push it to Dockerhub and finally deploy it to an AWS EC2 instance. If you're looking to get a Spring Boot To-Do application up and running in the cloud, you're in the right place. We'll walk through cloning the app from GitHub, creating a Docker image, and deploying it to AWS EC2. Don’t worry, it's actually a lot simpler than it sounds.

Step 1: Clone the GitHub Repository

First things first, you need to get the app's code. I have created a demo springboot todo app so that you can easily get started on creating the Dockerfile. Now go ahead, open up your terminal and run:

git clone https://github.com/ansuman-satapathy/demo-todoapp-for-dockerizing.git
mv demo-todoapp-for-dockerizing todoapp #renaming it to todoapp for easy navigation
cd todoapp #change into that directory

Once you are inside the project root folder, you'll already find a Dockerfile there. Well, that's the one I created. If you want to start from scratch, just delete that file or the content inside the file, as we will be using a file named 'Dockerfile'.

Step 2: Create a Dockerfile

Well, you already have one don't you? So, go ahead and open it with any text editor. A Dockerfile is like a recipe for Docker to build your application’s image. After that add the following content inside it.

Don't worry, I'll explain each line.

# Stage 1: Build Application
FROM maven:3.8.4-openjdk-17-slim AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package

#Stage 2: Extract the built JAR
FROM openjdk:17-jdk-slim AS runner
WORKDIR /app
COPY --from=builder /app/target/todoapp-0.0.1-SNAPSHOT.jar app.jar

#Stage 3: Running the Application
FROM openjdk:17-jdk-alpine AS final
WORKDIR /app
COPY --from=runner /app/app.jar .
EXPOSE 8080
ENTRYPOINT [ "java", "-jar", "app.jar" ]

This Dockerfile has three stages: one for building the app, one for preparing it to run and another for running it. Dividing the Dockerfile into multiple stages helps keep your docker image nice and small.

Exploring the Content of the Dockerfile

Building the Application:

FROM maven:3.8.4-openjdk-17-slim AS builder

FROM maven:3.8.4-openjdk-17-slim: This line specifies the base image for this stage. We are using a Maven image with OpenJDK 17 on a slim base to keep the size small. A base image is the starting point of a Dockerfile that provides a operating system and the environment your application will run in.
AS builder: This gives a name to this stage, so we can reference it later.

WORKDIR /app

WORKDIR /app: Sets the working directory inside the container to /app. All subsequent commands will be run from this directory.

COPY pom.xml .
COPY src ./src

COPY pom.xml .: This copies the pom.xml file from your local machine to the working directory in the container.
COPY src ./src: This copies the src directory from your local machine to the src directory in the container.

RUN mvn clean package

RUN mvn clean package: Runs the Maven command to clean and package the application. This will compile the code and package it into a JAR file.

Extracting the Built JAR and Preparing It To Run:

FROM openjdk:17-jdk-slim AS runner

FROM openjdk:17-jdk-slim: This line specifies the base image for this stage. We are using an OpenJDK 17 slim image to keep the size small.
AS runner: This names the stage runner for later reference.

WORKDIR /app

WORKDIR /app: Again sets the working directory inside the container to /app.

COPY --from=builder /app/target/todoapp-0.0.1-SNAPSHOT.jar app.jar

COPY --from=builder /app/target/todoapp-0.0.1-SNAPSHOT.jar app.jar: Copies the JAR file from the builder stage to the current stage. It takes the JAR from /app/target/todoapp-0.0.1-SNAPSHOT.jar in the builder stage and places it in the current /app directory as app.jar.

Running the Application:

FROM openjdk:17-jdk-alpine AS final

FROM openjdk:17-jdk-alpine: This specifies the base image for this final stage. We are using an OpenJDK 17 Alpine image, which is even slimmer and suitable for running the application.
AS final: This names the final stage final.

WORKDIR /app

WORKDIR /app: Sets the working directory inside the container to /app.

COPY --from=runner /app/app.jar .

COPY --from=runner /app/app.jar .: Copies the app.jar from the runner stage to the current directory (/app) in the final stage.

EXPOSE 8080

EXPOSE 8080: Tells Docker that the container will listen on port 8080 at runtime. This doesn't actually publish the port; it's more of a documentation for users of the image.

ENTRYPOINT [ "java", "-jar", "app.jar" ]

ENTRYPOINT [ "java", "-jar", "app.jar" ]: Specifies the command to run when the container starts. Here, it runs the JAR file using the java -jar command.

Now that we understand how a Dockerfile works, lets move forward.

Step 3: Build the Docker Image

So, now we have our Dockerfile ready. The next step is to build it and create a Docker image out of it. To do this, run this command in your terminal:

NOTE: Before proceeding, go ahead and create an account on Dockerhub. After that replace "your-dockerhub-username" with your actual username.

docker build -t your-dockerhub-username/todoapp:latest .

This command tells Docker to build an image using the Dockerfile we just created. After this command is successfully run, check that if any image was created. Run the below command to find images on your machine.

docker images

If you find an image named todoapp, then we have successfully created our docker image. Next is to upload it to Dockerhub.

Step 4: Push the Image to Docker Hub

To make your image available online, you need to push it to Docker Hub. Assuming you have created an account already, run this command:

Push your image:

docker push your-dockerhub-username/todoapp:latest

Step 5: Set Up an AWS EC2 Instance

Log in to AWS and go to the EC2 Dashboard.
Launch a new instance using an Ubuntu Server AMI.
Set up security groups to allow traffic on port 8080 by editing the inbound rules and adding a custom tcp rule for port 8080 to be open to everyone.

Step 6: Install Docker on Your EC2 Instance

Connect to your EC2 instance using SSH:

ssh -i your-key.pem ubuntu@<your-ec2-public-ip>

Install Docker by running these commands by following this tutorial. After that start Docker and ensure it runs automatically on boot:

sudo systemctl start docker
sudo systemctl enable docker

Step 7: Pull and Run Your Docker Image

Pull the Docker image you pushed earlier. This command basically pulls the image from your docker hub account inside the EC2 instance.
```
sudo docker pull your-dockerhub-username/todoapp:latest
```
Run the Docker container: Finally run the below command to run the image on port 8080 of the EC2 instance.
```
sudo docker run -d -p 8080:8080 your-dockerhub-username/todoapp:latest
```

Step 8: Check Your Application

Locate your public IP address for the EC2 instance. Then, open your web browser and go to:

http://<your-ec2-public-ip>:8080

Voila! You should see your To-Do application up and running!

Troubleshooting

Not reachable? Check that your EC2 security group allows traffic on port 8080.
Container not running? Use docker ps to see if the container is active and docker logs <container-id> for any errors.

Conclusion

We’ve now got a Spring Boot To-Do application running in the cloud with Docker and AWS EC2. It might seem like a lot at first, but with these steps, it’s pretty manageable. Enjoy your newly deployed app(terminate the instance if you are not rich), and happy coding!

Credits: (Image by pikisuperstar on Freepik)

AWS EC2: Creating, Connecting and Managing Your Instances

Ansuman Satapathy — Tue, 09 Jul 2024 20:45:22 +0000

If you have read the last article, you must have some idea about an EC2 instance. Amazon EC2 instances are basically virtual machines but in the cloud. This guide will walk you through creating your EC2 instance, securely connecting to it via SSH, and managing it effortlessly using the AWS Command Line Interface (CLI). But before that here are some features of EC2:

Features of AWS EC2

Flexibility: Choose from a wide range of instance types with varying CPU, memory, storage, and networking capabilities.
Scalability: Easily scale up or down based on demand, ensuring optimal performance and cost efficiency.
Security: Control access with security groups and manage authentication using key pairs for secure SSH access.
Integration: Seamlessly integrates with other AWS services like S3, RDS, and VPC for comprehensive cloud solutions.
Cost Management: Pay only for the resources you use with flexible pricing options and cost-effective billing.

AWS offers 12 months of free tier access to every new user. So if you want to experiment with it, go ahead, but be aware about the billing cycles. Amazon EC2 empowers businesses and developers to deploy applications quickly and efficiently, making it a cornerstone of cloud computing infrastructure. Now lets get started.

Creating Your EC2 Instance

Step 1: Select an AMI

Think of the Amazon Machine Image (AMI) as your instance’s operating system. Here’s how to get started:

Visit the EC2 Dashboard: Log in to AWS and go to the EC2 Dashboard.
Create Your Instance: Click on "Launch Instance" and choose an AMI. Popular choices include Amazon Linux and Ubuntu.

Step 2: Select the Instance Type

Choose the instance type that best fits your needs. For example, t2.micro is great for testing and small applications. Be careful here and only select the ones with free tier eligible tags or you will be charged for it.

Select Instance Type: Pick the hardware configuration that matches your workload.

Step 3: Create Key Pair

Create a key pair that will be used to connect to the EC2 instance. So save it somewhere safe.

Generate Keypair and save it: This will be used to securely connect to your EC2 instance.

Step 4: Configure Networking and Add Storage

Set up networking, storage, and any additional configurations. If you are just getting started, you can keep it as default and move on.

Configure Instance Details: Decide on networking settings and add storage as needed.

Step 5: Launch Your Instance

Review your configuration and launch your instance. Don’t forget to create or select a key pair for SSH access.

Connecting to Your EC2 Instance via SSH

Now that your instance is up and running, it’s time to connect to it securely:

Prepare Your Key Pair: Have your .pem key pair file ready.

Modify permissions in order to execute

chmod 600 keypair.pem
Connect via SSH:

Find your instance’s Public DNS (IPv4) in the EC2 Dashboard.

Use SSH to connect.
```
ssh -i /path/to/key-pair.pem ubuntu@<Public-IP-Address>
```

Managing EC2 Instances with AWS CLI

Harness the power of AWS CLI to manage your EC2 instances efficiently:

Install and Configure AWS CLI: If not already installed, set up AWS CLI with your AWS credentials.

Launch an Instance: Use a single command to launch an instance:

aws ec2 run-instances \
    --image-id ami-0a0e5d9c7acc336f1 \
    --count 1 \
    --instance-type t2.micro \
    --key-name MyKeyPairName \
    --security-group-ids sg-0a49d3aa3grs60 \
    --subnet-id subnet-05617gfhu90a934c1e

Check Instance Status:

aws ec2 describe-instances --instance-ids i-009ee048cd14619de

Terminate an Instance:

aws ec2 terminate-instances --instance-ids i-009ee048cd14619de

Conclusion

So with that we now have basic understanding of how to create an EC2 instance both through UI and through CLI, connecting to EC2 instances and managing the instances. This Knowledge will be helpful whether you are on a DevOps track or trying to learn about AWS in general. I will share more about AWS as I learn more about it. See you in the next one.

Introduction to Cloud Computing & AWS Cloud Services

Ansuman Satapathy — Mon, 01 Jul 2024 07:22:35 +0000

Cloud computing refers to the on-demand delivery of IT resources via the Internet, operating on a pay-as-you-go model. Instead of investing in and maintaining physical data centers and servers, users can leverage technology services like computing power, storage, and databases as needed from cloud providers such as Amazon Web Services (AWS).

Types of Deployment Models

On-Premises Deployment:

Running applications and services on dedicated infrastructure within the organization’s physical premises for maximum control and compliance.
Although you get complete control and enhanced security with on-premises deployment, the upfront costs and maintenance overhead are substantial and require ongoing investment.

Cloud Based Deployment:

Hosting applications and services entirely on third-party cloud infrastructure(like AWS) for scalability and cost efficiency.

Hybrid Deployment:

Combining cloud-based and on-premises infrastructure to leverage the benefits of both environments.
This is very flexible but increases complexity in management and integration.

Benefits of Using Cloud Computing

Cost Efficiency: Cloud computing allows businesses to trade upfront expenses for variable expenses, paying only for the resources they use. This shift from capital expenditures to operational expenditures reduces financial risk and improves budget management.
Simplified Operations: By leveraging cloud services, organizations can eliminate the need to run and maintain their own physical data centers. Cloud providers handle infrastructure management, including hardware maintenance, software updates, and security, freeing up internal IT resources for strategic initiatives.
Scalability: Cloud computing offers unparalleled scalability. Businesses can quickly scale resources up or down based on real-time demand, ensuring they have the right amount of computing power, storage, and networking capabilities without the delays and costs associated with traditional infrastructure scaling.
Economies of Scale: Cloud providers operate massive data centers worldwide, benefiting from economies of scale. This allows them to offer services at a lower cost than would be feasible for individual organizations managing their own infrastructure. Businesses can access enterprise-grade technology and infrastructure without the upfront investment.
Speed and Agility: Cloud computing enables businesses to innovate faster. Developers can provision resources within minutes, deploy applications rapidly, and iterate on software updates seamlessly. This agility helps businesses stay competitive by responding quickly to market changes and customer demands.
Global Reach: With cloud computing, businesses can expand their operations globally with minimal effort. Cloud providers have data centers in multiple geographic regions, allowing businesses to deploy applications closer to their customers for improved performance and compliance with local data regulations. This global infrastructure also enhances disaster recovery and business continuity capabilities.

What are AWS Cloud Services?

Amazon EC2 (Elastic Compute Cloud):
- EC2 provides resizable compute capacity in the cloud. It allows you to run virtual servers (instances) for various workloads, such as web applications, databases, and batch processing.
ELB (Elastic Load Balancing):
- ELB automatically distributes incoming application traffic across multiple EC2 instances to ensure optimal performance and fault tolerance of your applications.
AWS SNS (Simple Notification Service):
- SNS is a fully managed messaging service that enables you to send notifications from the cloud. It supports multiple communication protocols (HTTP, HTTPS, Email, SMS, etc.) to distribute messages to subscribers or other services.
AWS SQS (Simple Queue Service):
- SQS is a fully managed message queuing service that allows you to decouple and scale microservices, distributed systems, and serverless applications. It enables you to send, store, and receive messages between software components without losing messages or requiring other services to be available.
AWS Lambda:
- Lambda lets you run code without provisioning or managing servers. It automatically scales your application by running code in response to triggers (such as changes in data, HTTP requests, or timers), and you only pay for the compute time consumed.
AWS ECS (Elastic Container Service):
- ECS is a highly scalable, fast container management service that allows you to run, stop, and manage Docker containers on a cluster of EC2 instances. It integrates with other AWS services like ELB and IAM for enhanced container management.
AWS EKS (Elastic Kubernetes Service):
- EKS provides a managed Kubernetes service that allows you to run Kubernetes clusters on AWS without needing to install, operate, and maintain your own Kubernetes control plane or nodes.
AWS Fargate:
- Fargate is a serverless compute engine for containers that works with both ECS and EKS. It allows you to run containers without managing the underlying infrastructure. You specify the resources (CPU and memory) needed for your containers, and Fargate handles the rest.

These are some of the 100s of services that aws provides for scalable, reliable, and cost-effective solutions for building and running applications in the cloud, catering to a wide range of use cases from simple web applications to complex, distributed systems.

In the next article, we'll dive deeper into key AWS services like EC2, ELB, etc. exploring their features, how to use, and best practices for implementation. Stay tuned to uncover how these services can transform your cloud computing strategy and drive business success.

Introduction to DevOps: A Simplified Guide

Ansuman Satapathy — Mon, 24 Jun 2024 17:49:52 +0000

In the ever-evolving field of technology, understanding DevOps is becoming increasingly vital, especially for those preparing for job interviews or looking to improve their application delivery processes. This article provides a comprehensive overview of DevOps, breaking down its importance, core concepts, and evolution in the tech industry.

What is DevOps?

Definition and Goals

DevOps, short for Development and Operations, is a cultural practice that organizations adopt to enhance the efficiency and speed of their application delivery processes. It involves the integration of development and operations teams to improve collaboration and productivity. The main aim of DevOps is to streamline workflows, reduce errors, and deliver high-quality applications more rapidly.

Importance

Understanding DevOps is crucial for professionals in the tech industry. It’s often a topic in job interviews where you might need to explain its significance and what a DevOps engineer does on a daily basis. By adopting DevOps practices, organizations can achieve faster delivery times, improved product quality, and increased customer satisfaction.

Key Concepts of DevOps

Automation

One of the core principles of DevOps is automation. Automating repetitive tasks saves time and reduces the likelihood of human error. For instance, in a chip manufacturing company, automation helps improve production efficiency and quality control. Similarly, in software development, automation enhances the delivery process by ensuring consistent and reliable results.

Quality Control

Maintaining high code quality is another essential aspect of DevOps. By implementing quality control measures, teams can ensure that the code meets the required standards before it goes into production. This proactive approach helps in identifying and resolving issues early in the development cycle, leading to more stable and reliable applications.

Continuous Monitoring and Testing

DevOps emphasizes continuous monitoring and testing of applications. This involves keeping a close eye on the application’s performance and conducting regular tests to catch any issues early. Continuous monitoring ensures that any potential problems are identified and addressed promptly, minimizing downtime and improving the overall user experience.

The DevOps Process

Current Definition and Evolution

DevOps involves automating processes, maintaining code quality, and continuously monitoring and testing applications to improve delivery. Historically, developers would write code and pass it to a central system managed by DevOps engineers. This process has evolved to become more streamlined, with a greater emphasis on collaboration and efficiency.

Traditional vs. DevOps Approach

Traditional Roles

In the traditional approach, several roles were involved in the application delivery process:

System Administrator: Created the server.
Build and Release Engineer: Deployed the application.
Server Administrator: Managed the application server.

This manual and slow process often led to inefficiencies and delays.

Need for Change

The need for a more efficient and streamlined process gave rise to DevOps. The DevOps approach brings together these roles into a single team, improving communication and efficiency. This shift has enabled organizations to deliver applications faster and more reliably.

Emergence of DevOps

Single Team Approach

In the modern DevOps approach, a single team handles the entire process, from development to deployment and operations. This unified approach enhances communication and collaboration, leading to more efficient workflows and faster delivery times.

Role of a DevOps Engineer

A DevOps engineer is responsible for adapting to new tools and continuously improving the delivery process. When introducing yourself as a DevOps engineer, it’s essential to highlight your relevant experience and how you transitioned from previous roles to DevOps.

Preparing for DevOps Interviews

Highlight Experience

When preparing for DevOps interviews, it’s important to leverage your background (e.g., system administration) to demonstrate how it applies to DevOps. Be honest about your experience and emphasize your ability to adapt and learn.

Tools and Technologies

Familiarize yourself with specific tools and technologies commonly used in DevOps, such as GitHub Actions, Kubernetes, Ansible, and Terraform. Mentioning these tools during your interview can showcase your technical proficiency and readiness for the role.

Research and Discussion

Continual learning and engaging in discussions with other professionals can deepen your understanding of DevOps. Stay updated with the latest trends and best practices to remain competitive in the field.

Conclusion

Understanding DevOps is crucial for anyone involved in the tech industry. By embracing its principles and practices, organizations can significantly improve their application delivery processes, ensuring faster and more reliable outcomes. Whether you’re preparing for a job interview or looking to enhance your skills, mastering DevOps can open up new opportunities and drive success in your career.