Create Docker Image and run Kubernates using Springboot

1. Springboot.md

Step 1: Create project using spring.io

curl https://start.spring.io/starter.tgz -d type=gradle-project \
-d language=java \
-d bootVersion=2.6.5 \
-d baseDir=helloG \
-d groupId=com.example.hello \
-d artifactId=helloG \
-d description=Demo%20project%20for%20Spring%20Boot \
-d packageName=com.example.hello.helloG \
-d packaging=jar \
-d javaVersion=11 \
-d dependencies=devtools,web | tar -xzvf -

Then follow steps

Step 2:

./gradlew clean build

Check if the project is build properly.

java -jar build/libs/helloG-0.0.1-SNAPSHOT.jar

Step 3: Create Docker File

FROM adoptopenjdk/openjdk11:alpine
VOLUME /tmp
EXPOSE 9222

ARG JAR_FILE=./build/libs/helloG-0.0.1-SNAPSHOT.jar
COPY ${JAR_FILE} helloG-app.jar

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

Step 4.1:: Create docker image with tag [-t]

docker build -f Dockerfile -t hellog .

Step 4.2:: Check docker image proper or not

docker images
docker run -it --rm -p 8080:8080 hellog

docker network ls
docker create network mynet
docker run -it -p 8080:8001 --network mynet --name tulipnginx hellog
docker run -d -p 8080:8002 --network mynet --name tulipnginx hellog

Bonus

-p [localmachine port]: [docker container port]
sudo update-alternatives --config javac
sudo update-alternatives --config java
java -jar <path/to/my/jar> --server.port=7788
docker exec -it 377 /bin/ash

1.0 build_jar.sh

# clean build springboot application
./gradlew clean build

# Run project locally
java -jar build/libs/$1.jar

# Guide
# sh build_jar.sh helloG-0.0.1-SNAPSHOT

1.1 build_docker.sh

# build image
docker build -f Dockerfile -t $1

# check
docker run -it --rm -p 8080:8080 $1 .

# Guide
# With only tagname -> sh build_docker.sh hellog
# With only tagname + version -> sh build_docker.sh hellog:v1.0.0

2. kubernates.md

Step 1: Setup Minikube

minikube start
docker images
docker ps -a

Step 2: Load local Docker image into Minikube

minikube image load hellog

Step 3: Create deployment.yaml file

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hellog
  labels:
    name: hellog
spec:
  selector:
    matchLabels:
      name: hellog
  template:
    metadata:
      labels:
        name: hellog
    spec:
      containers:
        - name: hellog
          image: hellog
          imagePullPolicy: Never
          ports:
            - containerPort: 8080

Apply it using kubectl

minikube status
kubectl apply -f deployment.yaml

Step 4:

kubectl port-forward deployment/hellog 8080:8080

Delete Pods and deployment:

kubectl delete pods [name]
kubectl delete -f deployment.yaml

2.1 deploy.sh

# Setup Minikube
minikube start

# Add local docker image to kubernates
minikube image load $1

# apply config
kubectl apply -f deployment.yaml

# get app name from deployment.yaml file
appname=$( cat deployment.yaml  | grep 'name' -m 1 | awk '{print $2}' )

# Check if it working or not
kubectl port-forward deployment/$appname 8080:8080

# Guide
# sh deploy.sh hellog

Bonus 1: Nodejs.md

Step 1: Clone Git Repo

Git clone https://github.com/Abszissex/medium-local-docker-image-minikube

Step 2: Build container

cd app 
docker build -t pz/demo .

Step 3: Run container

docker run -it --rm -p 8080:8080 pz/demo

Reference

1. Local Docker Images in Minikube

Bonus 2: Clean_Kubernates.sh

query='gcr.io'

containerID=$( docker ps | grep $query | awk '{print $1}' )
imageID=$( docker images | grep $query | awk '{print$3}' )

minikube stop
docker rm $containerID
docker image rm $imageID

namespace.md

Step 1:

kubectl create namespace test

Step 2:

kubectl apply -f pod.yaml --namespace=test

Step 3:

kubectl get pods -A