DEV Community: aungkohtat

Deploying a Spring Boot Banking Application with Docker

aungkohtat — Mon, 28 Oct 2024 06:39:16 +0000

Containerizing applications is becoming increasingly important. In this guide, I'll walk you through deploying a Spring Boot banking application using Docker, first manually and then with Docker Compose. We'll cover everything from setting up the environment to running the application in containers.

Prerequisites

Before we begin, make sure you have:

An AWS Account
An Ubuntu EC2 instance (t2.medium)
Docker installed
Docker Compose installed
Basic understanding of Spring Boot and MySQL
(I already used vagrant box my local environment)

Project Overview

Our banking application is built with:

Spring Boot (Java)
MySQL Database
Maven for build management
Docker for containerization

Setup My Local Using Vangrant

cloning the repo from github and navigating to project code using git clone commad

Aungs-MacBook-Pro:cloud-native-box aungkohtet$ git clone https://github.com/aungkohtat/banking-app-project.git
Cloning into 'banking-app-project'...
warning: You appear to have cloned an empty repository.
Aungs-MacBook-Pro:cloud-native-box aungkohtet$ cd banking-app-project/
Aungs-MacBook-Pro:banking-app-project aungkohtet$ ls -la
total 56
drwxr-xr-x  10 aungkohtet  staff    320 Oct 28 09:06 .
drwxr-xr-x  28 aungkohtet  staff    896 Oct 28 09:05 ..
drwxr-xr-x   9 aungkohtet  staff    288 Oct 28 09:04 .git
-rw-r--r--@  1 aungkohtet  staff    905 Oct 28 07:51 Dockerfile
-rw-r--r--@  1 aungkohtet  staff   2781 Oct 28 07:51 README.md
-rw-r--r--@  1 aungkohtet  staff   1940 Oct 28 07:51 docker-compose.yml
drwxr-xr-x   5 aungkohtet  staff    160 Oct 28 07:52 images
-rw-r--r--@  1 aungkohtet  staff  10666 Oct 28 07:51 mvnw
-rw-r--r--@  1 aungkohtet  staff   2503 Oct 28 07:51 pom.xml
drwxr-xr-x   4 aungkohtet  staff    128 Oct 28 07:52 src
Aungs-MacBook-Pro:banking-app-project aungkohtet$

Part 1: Manual Deployment with Docker

Step 1: Create the Dockerfile

First, let's create a multi-stage Dockerfile to optimize our build:

# Stage 1: Build Environment
FROM maven:3.8.3-openjdk-17 AS builder
WORKDIR /app
COPY . /app
RUN mvn clean install -DskipTests=true

# Stage 2: Production Environment
FROM openjdk:17-jdk-alpine
COPY --from=builder /app/target/*.jar /app/target/bankapp.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/target/bankapp.jar"]

Step 2: Set Up Docker Infrastructure

Create a volume for MySQL data:

docker volume create mysql-bankapp

Create a network for container communication:

docker network create bankapp

Run MySQL container:

docker run -d --name mysql \
  -e MYSQL_ROOT_PASSWORD=Test@123 \
  -e MYSQL_DATABASE=BankDB \
  --network=bankapp \
  mysql:latest

Step 3: Build and Run the Application

Build the application image:

docker build -t bankapp-mini .

Run the application container:

docker run -d --name bankapp-mini \
  -e SPRING_DATASOURCE_USERNAME="root" \
  -e SPRING_DATASOURCE_URL="jdbc:mysql://mysql:3306/BankDB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC" \
  -e SPRING_DATASOURCE_PASSWORD="Test@123" \
  --network=bankapp \
  -p 8080:8080 \
  bankapp-mini:latest

Now we are ready to see our banking application
Which works properly, all functions works properly which you can see in images
take a look of images to see output :

-Register Account

My Dashboard

Deposit

withdraw

transfer money

Transaction History

Now stoping and deleting the exisiting container of bankapp-mini using command

docker stop 4f35135bde6c && docker rm 4f35135bde6c

Part 2: Deployment with Docker Compose

Now building same application by creating docker-compose.yml

Step 1: Create docker-compose.yml

Create a docker-compose.yml file to simplify deployment:

version: "3.8"

services:
  mysql:
    image: mysql:latest
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: Test@123
      MYSQL_DATABASE: BankDB
    volumes:
      - mysql-bankapp:/var/lib/mysql
    networks:
      - bankapp
    restart: always
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-pTest@123"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 30s

  bankapp:
    image: bankapp-mini
    container_name: bankapp-mini
    environment:
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/BankDB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
      SPRING_DATASOURCE_PASSWORD: Test@123
    ports:
      - "8080:8080"
    depends_on:
      - mysql
    networks:
      - bankapp
    restart: always

volumes:
  mysql-bankapp:

networks:
  bankapp:

Step 2: Deploy with Docker Compose

docker compose up

Dashboard

Key Features of Our Docker Setup

Multi-Stage Builds: We use multi-stage builds to keep our final image size small by separating the build environment from the runtime environment.
Volume Management: Persistent storage for MySQL data ensures we don't lose data when containers restart.
Network Isolation: Custom network ensures secure communication between containers.
Health Checks: MySQL container includes health checks to ensure the database is ready before the application starts.
Environment Variables: Configuration is handled through environment variables, making the setup flexible and secure.

Security Considerations

Configure AWS security groups to only allow necessary ports (8080 for the application).
Use environment variables for sensitive data instead of hardcoding values.
Implement proper database credentials and access controls.

Common Issues and Solutions

Connection Issues: If the application can't connect to MySQL, ensure both containers are on the same network and the MySQL container is healthy.
Port Conflicts: If port 8080 is already in use, map to a different port in your docker-compose.yml.
Volume Permissions: If MySQL can't write to the volume, check volume permissions and ownership.

Conclusion

Docker and Docker Compose significantly simplify the deployment of Spring Boot applications. While manual deployment gives you more control, Docker Compose offers a more maintainable and reproducible solution. Choose the approach that best fits your needs, considering factors like environment complexity and team expertise.

Remember to always follow security best practices and properly manage your AWS resources to avoid unnecessary costs.

Additional Resources

The complete source code for this project is available on GitHub at: my github repo

Building and Deploying a Dockerized Web Application

aungkohtat — Sun, 13 Oct 2024 15:18:01 +0000

In today’s fast-paced development world, containerization has become a crucial skill for developers and DevOps professionals alike. In this tutorial, we’ll walk through the process of creating a simple web application, containerizing it with Docker, and preparing it for deployment on a cloud platform.

Project Overview

Our project will consist of four main steps:

Creating a simple web application
Writing a Dockerfile
Building and running the Docker container
Preparing for deployment on a cloud platform

Let’s dive in!

Step 1: Create a Simple Web App

For this tutorial, we’ll use Node.js and Express to create a basic web application. If you don’t have Node.js installed, you can download it from the official website.

First, initialize a new Node.js project:

mkdir dockerized-web-app
cd dockerized-web-app
sudo apt update
sudo apt install nodejs npm
npm init -y
npm install express

Now, create a file named app.js with the following content:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello, Docker!');
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

This creates a simple Express server that responds with “Hello, Docker!” when you visit the root URL.

Step 2: Write a Dockerfile

Next, we’ll create a Dockerfile to containerize our application. Create a file named Dockerfile in your project directory with the following content

# Base image
FROM node:14

# Set working directory
WORKDIR /app

# Copy app files
COPY . .

# Install dependencies
RUN npm install

# Expose port
EXPOSE 3000

# Start the app
CMD ["node", "app.js"]

This Dockerfile does the following:

Uses Node.js 14 as the base image
Sets the working directory to /app
Copies our application files into the container
Installs dependencies
Exposes port 3000
Specifies the command to start our application

Step 3: Build and Run the Container

Now that we have our Dockerfile, let’s build and run our container:

# Build the Docker image
docker build -t my-web-app .
# Run the container
docker run -p 3000:3000 my-web-app

If everything went well, you should be able to visit http://localhost:3000 your browser and see "Hello, Docker!".

Step 4: Prepare for Cloud Deployment

The final step is to prepare our application for deployment on a cloud platform. For this example, we’ll use AWS Elastic Container Service (ECS), but the process is similar for other cloud providers.

Push your image to Docker Hub

docker tag my-web-app:latest akhlab/my-web-app:latest 
docker push akhlab/my-web-app:latest

Create an ECS cluster in the AWS Console.
Create a task definition using your Docker Hub image.
Create a service in your ECS cluster using the task definition.

The exact steps for cloud deployment can vary based on your specific requirements and the cloud provider you’re using. Be sure to consult your cloud provider’s documentation for detailed instructions.

Conclusion

In this tutorial, we’ve walked through the process of creating a simple web application, containerizing it with Docker, and preparing it for cloud deployment. This is just the beginning of what you can do with Docker and containerization.

Some next steps you might consider:

Add more complex functionality to your web application
Implement a CI/CD pipeline for automated testing and deployment
Explore Docker Compose for multi-container applications

Reference

Happy learning, and may your containers always be light and your deployments smooth!

Passwords vs Keys

aungkohtat — Mon, 30 Oct 2023 05:40:21 +0000

🔒 Passwords: The Basics

Passwords are the most common way to prove your identity online. However, they need to be strong to protect your accounts. Here's what you need to know:

Best Practices:

Use longer passwords (at least 8 characters).
Mix it up with numbers, upper and lower case letters, and symbols.
Avoid common words or simple substitutions.
Never reuse the same password for different accounts.
Change your passwords regularly.

🧐 Why Passwords Matter

Using weak or easily guessable passwords can put your accounts at risk. Attackers have many tricks up their sleeves to crack them.

💡 Password Managers to the Rescue

Password managers like KeePass, LastPass, and 1Password can make life easier:

🔑 KeePass: Keeps your passwords in a secure, encrypted database. Only remember one strong password.

🔗 KeePass

👉 To Install: brew cask install keepassxc

🔑 LastPass: Manage passwords online, across devices. Also, offers convenient browser plugins and mobile apps.

🔗 LastPass

🔑 1Password: A competitor to LastPass. Some prefer it due to its security features.

🔗 1Password

🔐 Public Key Authentication: The Advanced Way

For a higher level of security, you can use public key authentication. Here's how it works:

🔑 SSH (Secure Shell): Uses public key authentication to allow passwordless access to remote hosts.

📜 Steps to Set Up SSH:

Generate SSH keys with ssh-keygen -b 4096.
Copy your public key to the SSH server with scp.
Append the public key to authorized_keys.
Adjust file permissions with chmod.

Simple SSH Key Generate

# Generate SSH keys. Use the default file and empty passphrase for the keys.
ssh-keygen -b 4096

# Copy public key to SSH server
scp ~/.ssh/id_rsa.pub <HOST_NAME>:

# SSH to host
ssh <HOST_NAME>

# Append public key to authorized_keys
mkdir ~/.ssh
cat id_rsa.pub >> ~/.ssh/authorized_keys
rm id_rsa.pub

⚠️ Note: The private key should remain secret and have restricted file permissions.

🛡️ Advantages of Public Key Authentication:

Enhanced security through cryptographic keys.
Passwordless and non-interactive access.
Avoids the risk of password cracking.

🚫 Disadvantages of Public Key Authentication:

More complex setup.
If the private key is compromised, it's a security risk.

🚀 Tips and Tricks

Simplify login to different hosts using SSH config files.
Set defaults for hosts so you don't need to enter the same details repeatedly.

📄 Sample SSH Config File:

Host my_host
    Hostname ec2-42-42-42-42.us-west-2.compute.amazonaws.com
    User ec2-user
    IdentityFile ~/.ssh/host_public_key.pub

👉 Now, you can connect with ssh my_host effortlessly.

🔑 Deliverable: Create SSH keys, add the public key to an SSH server, and test logging in without a password.

So, choose your authentication method wisely—passwords for simplicity or public keys for enhanced security. Stay safe online! 🌐🔐

Building a Cloud-Powered Static Website: A Step-by-Step Guide

aungkohtat — Mon, 23 Oct 2023 16:20:51 +0000

Building a Cloud-Powered Static Website: A Step-by-Step Guide

cloud resume challenge

In today’s competitive job market, a well-crafted resume is essential, but it’s no longer just about words. Employers now seek hands-on experience with modern technology, particularly cloud computing. To help you demonstrate these skills, we introduce the Cloud Resume Challenge, a practical project series. In this article, we’ll guide you through the first part of the challenge, where you’ll build a static website hosted on Amazon S3, optimize content delivery with CloudFront, and set up a custom domain using Route53 DNS.

Step 1: Setting up an S3 Bucket

Amazon S3 is our storage solution. Go to the Amazon S3 console.
Click “Create Bucket.”
Give your bucket a unique name, choose a region, and use default settings.
Click “Create” to create your S3 bucket.

enable static website hosting

Create a policy

{

    "Version": "2012-10-17",

    "Statement": [

        {

            "Effect": "Allow",

            "Principal": "",

            "Action": "s3:GetObject",

            "Resource": "arn:aws:s3:::aungkohtet-cloud-resume-challenge/"

        }

    ]

}

Step 2: Uploading Your Website Files to S3

With your S3 bucket ready, it’s time to upload your website files. You can do this by dragging and dropping files in the S3 console or by using the AWS CLI.

Step 3: Implementing CloudFront for Faster Delivery

CloudFront, a content delivery network (CDN), speeds up content delivery by caching it globally.
Open the AWS Management Console and go to the CloudFront dashboard.
Click “Create Distribution.”
Choose your S3 bucket as the origin.
Configure other options as needed.
Click “Create Distribution.”

Note: Repeat these steps for both “alexiscloud.tech” and “blog.alexiscloud.tech” domain names if you have them.

Step 4: ACM Request

Step 5: Configuring Route53 DNS

Route53, Amazon’s DNS service, ensures your domain points to your website.
Register your domain with Route53 (a Hosted Zone will be created automatically).
Open the Route53 dashboard.
Click on the Hosted Zone linked to your domain name.
Add an “A” record pointing to the CloudFront Distribution domain name.
Save your changes.

Your static S3 website is now ready to be accessed using the domain associated with it. You can see an example website created for this challenge at https://alexiscloud.tech to visualize the result of your efforts.

By completing this first part of the Cloud Resume Challenge, you’ve gained the skills to build a static S3 website, enhance content delivery with CloudFront, and configure Route53 DNS for a custom domain. Your website is live and ready for visitors. Congratulations!

Challenges with Terraform Cloud Login and Gitpod Workspace Integration

aungkohtat — Sun, 22 Oct 2023 15:06:18 +0000

Challenges with Terraform Cloud Login and Gitpod Workspace Integration

Logging into Terraform Cloud within a Gitpod workspace can be a bumpy ride. When attempting to use terraform login, the browser-based wiswig view doesn't always generate the token as expected. Fortunately, a workaround exists: manually creating a token in Terraform Cloud. This short note explores the common issues faced in integrating Terraform Cloud login with Gitpod workspaces and provides a practical solution: creating your token in Terraform Cloud.

Issues with Terraform Cloud Login and Gitpod Workspace

When attempting to run terraform login it will launch bash a wiswig view to generate a token. However it does not work expected in Gitpod VsCode in the browser.

1.The workaround is manually generate a token in Terraform Cloud

<https://app.terraform.io/app/settings/tokens?source=terraform-login>

2.Then create open the file manually here:

touch /home/gitpod/.terraform.d/credentials.tfrc.json
open /home/gitpod/.terraform.d/credentials.tfrc.json

3.Provide the following code (replace your token in the file) :

{
  "credentials": {
    "app.terraform.io": {
      "token": "YOUR-TERRAFORM-CLOUD-TOKEN"
    }
  }
}

4.terraform login:

yes
Ctrl+O

choose P

Ctrl+click to link

5.Gentrate token

go to >> /home/gitpod/.terraform.d/credentials.tfrc.json

7.Here’s an example of the JSON structure for credentials.tfrc.json:

{
  "credentials": {
    "app.terraform.io": {
      "token": "YOUR_API_TOKEN"
    }
  }
}

add the key

In conclusion, tackling Terraform Cloud login issues, especially in Gitpod workspaces, requires adaptability. The workaround of manually generating a token in Terraform Cloud is a practical solution, ensuring uninterrupted access to Terraform’s powerful infrastructure management tools. Stay agile and resourceful to make the most of this valuable DevOps asset.

GitHub — aungkohtat/terraform-beginner-bootcamp-2023

aungkohtat — Sun, 22 Oct 2023 15:04:40 +0000

GitHub — aungkohtat/terraform-beginner-bootcamp-2023

This article is part of my cloud journey with terraform beginner bootcamp by Andrew Brown.

TerraTowns serves as a centralized platform where terraformers can explore and link up with each other’s self-hosted personal websites (TerraHouse), reminiscent of the Geocities style of 2023. The terraformers utilize Infrastructure as Code (IaC) to launch their TerraHouse, a Content Management System (CMS) that empowers them to create their own personal websites and integrate them into the TerraTowns network.

Week 0 — PreweekWeek 1 — Build

Week 2 — ConnectWeek 3

Originally published at https://github.com.

Launching an EC2 Instance with Docker for running Cruddur App

aungkohtat — Sun, 22 Oct 2023 14:58:46 +0000

Launching an EC2 Instance with Docker for running Cruddur App

I am passionate about all things cloud ..!

This article is part of my cloud journey with aws bootcamp by Andrew Brown.

Let’s Begin!!

1. Push Docker Images into the DockerHub

1.Create a DockerHub Account

The first step is to create a DockerHub account if you don’t already have one. Visit DockerHub and sign in.

2.Generate an Access Token

Upon logging in to your DockerHub account, you’ll land on the dashboard. To create an Access Token, simply click on your profile picture located in the top right corner, triggering a dropdown menu to appear.

3.Log in to Docker Account

In your Gitpod terminal, use the following command to log in to your Docker account, replacing “alexiscloud” and the access token with your credentials.

Profile >> Account settings >> Security >> New Access token

Generate new token

Log in to Docker Account with gitpod terminal

In your Gitpod terminal, log in to your Docker account using the following command, replacing “akhlab” and the access token with your credentials.

To upload the docker images without giving any tag (by default it uses the “Latest” tag) run the following commands

 docker image tag aws-bootcamp-cruddur-2023-backend-flask:latest  akhlab/cruddur-backend

 docker image tag aws-bootcamp-cruddur-2023-frontend-react-js:latest akhlab/cruddur-frontend

 docker image push akhlab/cruddur-backend:latest

 docker image push akhlab/cruddur-frontend:latest

Your DockerHub account will display these images in the Repositories section

2. Create new git Repositroy

Provide the new repository with the name ‘docker-compose-cruddur,’ set it to ‘Public,’ and click ‘Create repository.

Create a new file and name it docker-compose.yml and add this code to your file and click on commit.

 version: "3.8"
 services:
   backend-flask:
     environment:
       FRONTEND_URL: "http://${ips}:3000"
       BACKEND_URL: "http://${ips}:4567"
     image: akhlab/cruddur-backend
 #    build: ./backend-flask
     ports:
       - "4567:4567"
     volumes:
       - ./backend-flask:$HOME/backend-flask
   frontend-react-js:
     environment:
       REACT_APP_BACKEND_URL: "http://${ips}:4567"
     image: akhlab/cruddur-frontend
 #    build: ./frontend-react-js
     ports:
       - "3000:3000"
     volumes:
       - ./frontend-react-js:$HOME/frontend-react-js

 # the name flag is a hack to change the default prepend folder
 # name when outputting the image names
 networks: 
   internal-network:
     driver: bridge
     name: cruddur

Change yout dockerhub image name.

3.Create EC2 instance

5.Manually select also for paid instance

Next, navigate to ‘Advanced details,’ scroll to the bottom, and paste the code into the ‘User data’ section for Docker installation and service provisioning.

Remember to press ENTER to ensure the seamless execution of the provided commands.

 #!/bin/bash

 # This will update the ec2 instance 
 sudo yum update -y

 # This will install docker into ec2 instence
 sudo yum install docker -y

 # This will install pythong3-pip to install docker compose
 sudo yum install python3-pip

 # This will install docker-compose
 sudo pip3 install docker-compose

 # This specifies that docker service will run every time when this ec2 instence starts
 sudo systemctl enable docker.service

 # This command will run the docker services
 sudo systemctl start docker.service

10.

11.

12.

Set up three inbound rules as follows and save them:

Type: Custom TCP, Port: 3000, Source: Custom
Type: SSH, Port: 22, Source: Custom
Type: Custom TCP, Port: 4567, Source: Custom

These rules control incoming traffic to your AWS instance.

Then once again click on connect ec2 and running following script

# To give ec2-user permission to use docker without root (BEST PRACTICE)
sudo usermod -a -G docker ec2-user
id ec2-user
newgrp docker

# This environment variable will be used by docker-compose file 
export ips=$(curl http://169.254.169.254/latest/meta-data/public-ipv4)

# Volumes for frontend and backend
mkdir $HOME/backend-flask
mkdir $HOME/frontend-react-js

# To download docker-compose file directly from my github repo (PS IT IS MY GITHUB REPO)
sudo yum install git -y
git clone https://github.com/ohmykloud/docker-compose-cruddur.git

# Gitclone command will make a directory/ changing the directory 
cd docker-compose-cruddur

# Putting the file to home directory
mv docker-compose.yml $HOME/docker-compose.yml

# Changing the directory to Home
cd ..

# RUN THE CONTAINERS TO ENJOY CRUDDER INSIDE EC2
docker-compose -f /home/ec2-user/docker-compose.yml up -d

13.Modify git link and install at ec2 instance

14.

15.

Run ‘docker-compose -f /home/ec2-user/docker-compose.yml up -d ’ and you’ll see a successful launch confirmation. To access the Cruddur App, open a new tab in your web browser and paste the public IP address into the URL bar.