Forem: Luke

Pull/Push in DevOps

Luke — Sun, 16 Nov 2025 16:34:25 +0000

Push-based or Pull-based are synchronize code/config between dev, server and repository - but mechanism of synchronization is different.

Push-based

In push-based, we'll have an CI/CD flow which active "push" the changes to server. This model usually use in traditional deployment, apply the changes after pipeline run directly.

Pros:
- Easy to deployment
- Re-use existing pipeline
- Immediate execution
Cons:
- Hard to track drift
- Pipeline dependence
- Rollback missing
- Security risk
- Audit challenges

Pull-based

In pull-based, the server actively pulls changes from the project’s repository. This approach is called GitOps, where Git acts as the Single Source of Truth. The workflow is similar to push-based, but with some key differences - The pipeline won't deploy to server directly - We add an agent (ArgoCD / Flux) to the server side, which continuously observes the project’s repository and pulls the changes to apply them to the server whenever updates occur.

Pros:
- Automation
- Easy rollback
- Multi-cluster support
Cons:
- Agent installation
- Complex configuration
- Polling latency

Comparison

Criteria	Pull-Based	Push-Based
Status Synchronization	Automation	Manual (triggered by pipeline run)
Installation	Install agent in server side	No need agent
Suitable For	Kubernetes, multi-cluster, complex project	Medium-sized project, simple pipeline
Security	More secure (server only pulls from Git)	High risk (pipeline needs direct access to server)

Git - Dev/DevOps best friend

Luke — Fri, 26 Sep 2025 20:45:51 +0000

In a software, Git is more than just a version control system - It's a backbone of the entire project. It acts as a single source of truth, it store anything related to code and infrastructure.

Why Git is important

Git solves 3 big problems:

History changes:Every changes is recorded, making it easy to review, revert, or understand the evolution of the code.
Automation workflow:Git integrates seamlessly with CI/CD pipelines, enabling automated testing, building, and deployment.
Made/keep an update:Git ensures that everyone works with the latest version, reducing conflicts and improving team efficiency.

Tips for using Git effectively

Small commit and clearly message: You should commit a small part, not a big change and writing clearly message which describe what you did
Give a meaning name for branch: Don't make your team member be confuse or guessing what the branch do
Keep the main branch stable: Ensure code in main branch is always stable, even new members can clone and run it without error
Tag version: Tagging version for rollback / manage easily

Branching strategy in Git

Now a day, we have two popular strategies

Git flow
Trunk-Based

Let's take a look into it 👀

Git flow

In real-world projects, we often create many branches—and each branch serves a specific purpose. Depending on your company or team, branch names might differ, but they should still align with the core structure of Git Flow.

main: production-ready branch, it contain stable and deployable code
hotfix: Urgent fixes for production issues. Branched from main and merged into both main and develop
release: Code ready for final testing before merging into main
develop: The integration branch for development
features: Developing new features, typical branched from develop and merged back when completed

We can use git flow for a big team or projects have complex release cycles

Trunk-Based

In trunk-based, we only have two branches main and features, with features's life-time is smaller and shorter than git flow (usually 2-3 days). This strategy helps us take advantage of automation in git.

We can use trunk-based for a small team or pet projects

Conclusion

Choosing a right strategy will help your team deliver product faster and reliable. No need to follow the others, just choose your best suite 😎

Happy Coding!

Introduction to CI/CD

Luke — Fri, 26 Sep 2025 18:49:37 +0000

As a developer, at least one time you said or heard...

Including me also 🤣 So why it happened? Hmmm...Many factors "contribute" to this, example:

Code conflict
Integration error
Process Manual
etc.

And CI/CD has born to helps us fix those issues

What is CI/CD

CI/CD are the short term for Continuous Integration & Continuous Delivery/Deployment. It helps the process become automated and deliver product to client in a reliable and fastest way.

CI/CD overview

Continuous Integration - CI

CI overview

In CI, whenever a developer commit changes to the repository, it'll build & run test automatically. This helps ensure code is reliable and runnable, ready to integrate with the rest of the team's work. So with CI implementation, we can get the feedback right away after we commit, no need to wait the others for build and test

Continuous Delivery/Deployment - CD

When your changes reach CD, the next phase after CI, it means they’re packaged, tested, and ready to be deployed to staging or production environments.

In CD, there are two definitions.

Continuous Deliver: Code is ready to deploy, but it need someone - maybe you, to click approve for deployment => best suitable for production environments
Continuous Deployment: The code is automatically deployed to the target environment as soon as it passes all the checks, it's hands-free deployment => ideal for staging environments

CD overview

Conclusion

We've covered the basics of CI/CD. If your team/project hasn't implemented it yet, consider doing so, you'll likely find it beneficial. In the next post, I will cover some tips/tools can use in CI/CD.

Happy Coding!

Pod - The smallest unit in Kubernetes

Luke — Fri, 05 Sep 2025 16:10:11 +0000

I have gone through Kubernetes architecture in the past, you can go over here. In that article, we know Kubernetes run application in the place call Pod

What is Pod?

Pod is the smallest unit in Kubernetes for deploy and run an application. Pod can contain one or many containers and they sharing the pod's resource for each others.

Pod example

Deploy the first app

I would use simple image okteto/hello-world:node for test. Or you can deploy custom image to docker hub by yourself, I have written in this article

apiVersion: v1 
kind: Pod # Declare Pod resource
metadata:
  name: hello-pod # The name of the pod
spec:
  containers:
    - image: okteto/hello-world:node # Image to create the container
      name: hello-pod # The name of the container
      ports:
        - containerPort: 3000 # The port the app is listening on 
          protocol: TCP

Access to your master node and create the file test.yaml with content above. After that, run

kubectl apply -f test.yaml

Check it deploy success or not by the command

kubectl get pod

It must show the pod with name hello-pod and status is running

If status is ContainerCreating, wait for a few minutes and try again because the container is being create. To ensure the image runs correctly, I will use a network proxy for expose the port. Currently, here is my app

Run the command

kubectl port-forward pod/hello-pod 3000:3000

It will expose port 3000, listening and coordinating access to the container app on the same port.

Test it with curl localhost:3000, if you receive hello message...You have your first app with Kubernetes 🎉

Conclusion

We have deploy and run simple app with pod in Kubernetes. In reality, no one deploy and run app like this 🤣, they usually use Deployment, StatefulSet, DaemonSet. But that is another article, the goal of this post is to show you what a Pod is and its intend.

In the next article, I will write how to group and manage pod by label and namespace

Happy Coding!

YAML - Kubernetes 'Favorite' Configuration Language

Luke — Fri, 05 Sep 2025 09:26:39 +0000

When work with Kubernetes, we can interact with it via UI (I'll write about it in future) or configuration languages (YAML, JSON or HCL). This post will focus on YAML - Yet Another Markup Language.

Structure

When we import a YAML file in Kubernetes, we create a Kubernetes object which is a persistent entity in the cluster. Examples:

Pod - the place where you run your application
Service - a way to expose your app
Deployment - manage replicas and update
ConfigMap, Secret, Ingress, etc.

We just need focus to four primary top-level fields in YAML

apiVersion: Specifies the version of the Kubernetes API that the object belongs to. For example:
- apps/v1 for Deployments
- v1 for Pods and Services.
kind: Defines the type of Kubernetes object being created. Common examples include Pod, Deployment, Service, ReplicaSet, Ingress, etc.
metadata: Contains data that identifies the object within the cluster and provides descriptive information. This typically include:
- name: unique name for object (require)
- namespace: namespace the object belong to, default namespace is default (optional)
- labels: Attach label for object, it help another object can select base on this
- annotation: Often used for tools or specific configurations.
spec: Object configuration. The content of this section depending on the kind of object. For example:
- For a Deployment kind, spec defines the number of replicas, the pod template (including container images, ports, and resource limits), update strategy, and selectors.
- For a Service kind, spec defines the port mappings, selector to find target pods, and type of service (e.g., ClusterIP, NodePort, LoadBalancer).
- For a Pod kind, spec defines the containers within the pod, volumes, restart policy, etc.

Example of YAML in deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  generation: 2
  labels:
    app: wordpress #EX: app:front-end
  name: wordpress
  namespace: wp-ecommerce
spec:
  progressDeadlineSeconds: 600
  replicas: 2
  revisionHistoryLimit: 11
  selector:
    matchLabels:
        app: wordpress #EX: app:front-end
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: wordpress  # ✅ This matches the selector
    spec:
      containers:
        - image: wordpress:latest
          imagePullPolicy: Always
          name: wordpress
          ports:
            - containerPort: 80
              name: tcp
              protocol: TCP
      restartPolicy: Always

If you want run it in Kubernetes, just run in your master node

kubectl apply -f your-yaml-file.yaml

Conclusion

In reality, others people can use JSON / HCL for Kubernetes too. But for some reason, maybe it look cooler 👀 (J4F), they usually use YAML for Kubernetes. Each format has its pros and cons, use what you're comfortable with.

Happy coding !

Kubernetes Architecture Overview

Luke — Thu, 04 Sep 2025 10:26:59 +0000

What is Kubernetes?

Kubernetes (or K8s) is an open-source developed by Google for container management. It can deploy on vary platform (On-premise, Cloud, Virtual Machine). Many large companies use it for system deployment and management.

Why is Kubernetes?

We have several popular ways to deploy application

Traditional

Virtualized

Container

Each approach has its advantages and disadvantages. Here, I will focus on the third approach (Container), which is more popular than the others. For a simple term, think of your server as a ship, and each container it carries is an isolated application ready to be deployed. Sound great, but we have another problem:

How we manage it? 🤔
How we scale it? 🤨
What happen if the "ship" drown? 😱

When we're anxious to find a solution, Google offers helpful solution - Kubernetes 😎

How Kubernetes work?

Kubernetes enables application grouping and management via namespaces, and its Services facilitate traffic routing to the correct applications. When a "ship" drown, it move our container to another "ship" to ensure high availability for the app. And many, many things we can work on it. And here is the "secret" behind it - architecture

Control plane (Master node)

It responsible for application management and high availability (HA). We never run application on it.

API Server

Kubernetes's heart
All components must communicate through it, not directly.

Control manager

It contain vary controller for each purpose (deployment, services, storage, etc.)

Cloud control manager

Only appear on cloud platform

Scheduler

Resource coordinator

etcd

A database stores the cluster's state, including configurations, node data, pod data, and service data.

P/s: Backing up etcd is crucial for Kubernetes availability.

Node (Worker node)

The application will run inside this; the number of worker nodes is limited only by your budget.

And worker node have 3 mains components:

Container Runtime Interface (CRI)

Run container (docker, containerd or something else)
A CRI contains one or more pods, each representing an application

Kubelet

Receive and execute from API Server
Transmit system information to API server
Ensure containers/pods run correct state
Continuously report pod/node status to the control plane and manage the pod lifecycle on the node

Kubernetes Service Proxy

Maintain network rules for pod connectivity within and outside the cluster

Conclusion

We have go through the Kubernetes architecture and know what is it. In the next post, I will guide you install and run Kubernetes with on-premise system.

Happy Coding!

Deploy Kubernetes On-Premises From Zero

Luke — Sat, 16 Aug 2025 13:59:46 +0000

Resource Preparation

Name	IP	Role	RAM	CPU	OS
k8s-master-1	192.168.1.111	Control Plane	3	2	Ubuntu 22.04 LTS
k8s-master-2	192.168.1.112	Worker	3	2	Ubuntu 22.04 LTS
k8s-master-3	192.168.1.113	Worker	3	2	Ubuntu 22.04 LTS

Implementation Steps

1) Update system

sudo apt update -y && sudo apt upgrade -y

2) Add hosts (above all 3 virtual machines)

Open file host to config ip address

vim /etc/hosts/

Add those configs into file

192.168.1.111 k8s-master-1
192.168.1.112 k8s-master-2
192.168.1.113 k8s-master-3

Saved and check

ping <ip-addr>

3) Create a new user

We should create/switch to another user (avoid using root) to install kubernetes

Create devops user and add to sudo group

adduser devops
usermod -aG sudo devops

Switch to devops

su devops
cd /home/devops

4) Turn off swap

Because Kubernetes require actual RAM to ensure about performance and stable

# turn off swap forever
sudo sed -i '/swap/s/^/#/' /etc/fstab

5) Download and add module into kernel

System will download overlay & br_netfilter package manually, this is two modules which require for k8s implement

overlay: Support overlay filesystem, it's necessary for containerd to manage container image.
br_netfilter: Allow filter network package on bridge network, it's very important for Kubernetes to handle traffic between container.

sudo modprobe overlay
sudo modprobe br_netfilter

To make system automatically install two modules above after restart, we need modify config file by command below

sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

6) Config network

Those config to make sure:

Kubernetes can manage traffic between containers and Pods.
Firewall rules can apply to traffic via bridge network.
The system can routing package between nodes in cluster.

echo "net.bridge.bridge-nf-call-ip6tables = 1" | sudo tee -a /etc/sysctl.d/kubernetes.conf
echo "net.bridge.bridge-nf-call-iptables = 1" | sudo tee -a /etc/sysctl.d/kubernetes.conf
echo "net.ipv4.ip_forward = 1" | sudo tee -a /etc/sysctl.d/kubernetes.conf

Apply sysctl config

sudo sysctl --system

7) Install docker

sudo apt install -y curl gnupg2 software-properties-common apt-transport-https ca-certificates
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/docker.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

8) Install & config containerd

This is container runtime which is use by Kubernetes for manage container

sudo apt install -y containerd.io

After installed, we need config containerd use Systemd to manage resource group (cgroup) => This make resource management become consistent.

containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

Restart containerd

sudo systemctl restart containerd
sudo systemctl enable containerd

9) Install Kubernetes package

Config to download from legit source

echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Install packages (kubelet, kubeadm, kubectl)

sudo apt install -y kubelet kubeadm kubectl

For avoid auto upgrade version => Ensure package versions are consistent.

sudo apt-mark hold kubelet kubeadm kubectl

Deploy model (1 master - 2 worker)

Standard model

Init Kubernetes on master node

sudo kubeadm init
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

After the initial setup, it'll have command follow format below - use it to add worker

sudo kubeadm join <ip-master-node>:6443 --token <your_token> --discovery-token-ca-cert-hash <your_sha>

Add worker node

Copy command from master node and paste it to machine where role determine is worker role (maybe you need to run it with sudo)

Verify

Run kubectl get node -o wide in master node to check worker added

Example output

Conclusion

Just one of over 35 ways to install Kubernetes. In the future, to add more workers to your system, simply run

sudo kubeadm join <ip-master-node>:6443 --token <your_token> --discovery-token-ca-cert-hash <your_sha>

In the next post of series, I will show you how to use cloud for Kubernetes
Happy Coding!

Multi-host deployment and management using Portainer

Luke — Sat, 26 Jul 2025 18:22:16 +0000

TL;DR

I will simulate a multi-host environment using DinD and then use Portainer for deployment and management.

Prerequisite

Installed Docker (If you don't have it, follow the instructions for Windows or Linux)
Read previous post to know what I done

Architecture

I will migrate from a single-host to a multi-host architecture.

Multi-host

Install Portainer

Step 1: Register 3 nodes free for portainer

Click on the link
Fill out the form
Get an email and save the license key

Email license key

Step 2: Create docker volume for portainer

docker volume create portainer_data

Step 3: Create network

docker network create portainer-network

Step 4: Run portainer with specify network

docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always --network portainer-network -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ee:lts

Step 5: Access portainer via localhost:9443/#!/endpoints to create account

Step 6: Register license key you get from email

Home page

Push image to docker registry

Step 1: Open terminal and run (it will will be prompted to enter Docker ID (username) and password interactively)

docker login

Step 2: Tagging image with the following format <your-username-docker>/<application-name>:<version>. Your username should be the same display on docker

For me, username is locnguyenpv

docker tag project-management/client-app locnguyenpv/client-app:v1

docker tag project-management/project-service locnguyenpv/project-service:v1
docker tag project-management/user-service locnguyenpv/user-service:v1
docker tag project-management/task-service locnguyenpv/task-service:v1

Step 3: Push image to registry by tag

docker push locnguyenpv/client-app:v1

docker push locnguyenpv/project-service:v1
docker push locnguyenpv/user-service:v1
docker push locnguyenpv/task-service:v1

Connect to DinD

Step 1: Create 2 DinD, one for FE, one for BE

docker run --privileged -d --name project-management-fe --network portainer-network -p 80:80 -p 9002:9001 -p 2377:2375 docker:dind

docker run --privileged -d --name project-management-be --network portainer-network -p 2376:2375 -p 9001:9001 -p 9099:9099 docker:dind

Step 2: SSH into each DinD to install Portainer Agent

docker exec -it project-management-fe sh
docker run -d \
  -p 9001:9001 \
  --name portainer_agent \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /var/lib/docker/volumes:/var/lib/docker/volumes \
  -v /:/host \
  portainer/agent:2.27.9

docker exec -it project-management-be sh
docker run -d \
  -p 9001:9001 \
  --name portainer_agent \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /var/lib/docker/volumes:/var/lib/docker/volumes \
  -v /:/host \
  portainer/agent:2.27.9

Step 3: Connect DinD with Portainer

Connect Success

Update docker-compose

Now that I've pushed the image to the Docker registry, I can use it instead of building from source. Replace build from source to pull image from registry

services:
  client-service:
    image: locnguyenpv/client-app:v1
    ports:
      - "80:80"
    restart: always

services:
  mysql-service:
    image: mysql:latest
    container_name: mysql-container
    environment:
      MYSQL_PASSWORD: 123123
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql  # create space for persistence data
      - ./database:/docker-entrypoint-initdb.d # Mount init file into container 
    healthcheck:  # Check every 10s to make sure it work fine
      test: ["CMD-SHELL", "mysqladmin -u root -p$MYSQL_PASSWORD ping -h localhost || exit 1"]
      interval: 30s
      retries: 5
      timeout: 10s
      start_period: 10s
    networks:
      - internal-network

  nginx:
    image: nginx:latest
    container_name: nginx-gateway
    ports:
      - "9099:9099"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro # Mount nginx config from local to container
    depends_on:        # Start condition
      - project-service
      - user-service
      - task-service
    networks:
      - internal-network   # Virtual network
  project-service:
    image: locnguyenpv/project-service:v1
    container_name: project-service-container
    ports:
      - "8081:8081"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  user-service:
    image: locnguyenpv/user-service:v1
    container_name: user-service-container
    ports:
      - "8082:8082"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  task-service:
    image: locnguyenpv/task-service:v1
    container_name: task-service-container
    ports:
      - "8083:8083"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network

networks:
  internal-network:
      driver: bridge
      name: internal-network

volumes:
  mysql-data:

Deploy to DinD

Step 1: Go to home page and choose DinD

Step 2: Choose stack

Step 3: Add new stack

Step 4: Copy & paste docker-compose file into editor

Step 5: Deploy

Deploy success

Replace those steps for other DinD. All set!

Conclusion

I just show you the way how to simulate multi-host environment by DinD. After that, use Portainer for management and deployment.

Happy Coding

Docker-in-Docker (DinD)

Luke — Sat, 26 Jul 2025 13:07:51 +0000

What is DinD?

For a simple terms, I will use docker to run another docker in docker 🤪

DinD Methodology

Why is it?

It can be used in many cases, but I use it to simulate a multi-host environment on a single physical machine.

How to do it?

Open your command line and run it

docker run --privileged -d --name <your-docker-name> docker:dind

That's it, now I have a "virtual" of virtual machine to deploy and run the image

Warning ❗❗❗: Because it run with --privileged, so it's only use for dev/test environment => Never use in production

Deploy microservice with Docker from scratch - P2

Luke — Sun, 20 Jul 2025 09:15:03 +0000

TL;DR

Use Docker Compose to run and deploy a project's Dockerfiles as microservices.

Docker-compose

In the previous post, I have an overview of the project and its functionality. In this post, I'll delve into implementation details. I will go through each layer of the project

Client App (FE)

client-service:
    build:
      context: ./client-app
      dockerfile: Dockerfile
    container_name: client-app-container
    ports:
      - "80:80"
    restart: always # Auto restart when it fail

Nginx

nginx:
    image: nginx:latest
    container_name: nginx-gateway
    ports:
      - "9099:9099"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro # Mount nginx config from local to container
    depends_on:        # Start condition
      - project-service
      - user-service
      - task-service
    networks:
      - internal-network   # Virtual network

Server (BE)

 project-service:
    build:
      context: ./project-service
      dockerfile: Dockerfile
    container_name: project-service-container
    ports:
      - "8081:8081"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  user-service:
    build:
      context: ./user-service
      dockerfile: Dockerfile
    container_name: user-service-container
    ports:
      - "8082:8082"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  task-service:
    build:
      context: ./task-service
      dockerfile: Dockerfile
    container_name: task-service-container
    ports:
      - "8083:8083"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network

Database (MySQL)

  mysql-service:
    image: mysql:latest
    container_name: mysql-container
    environment:
      MYSQL_PASSWORD: 123123
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql  # create space for persistence data
      - ./database:/docker-entrypoint-initdb.d # Mount init file into container 
    healthcheck:  # Check every 10s to make sure it work fine
      test: ["CMD-SHELL", "mysqladmin -u root -p$MYSQL_PASSWORD ping -h localhost || exit 1"]
      interval: 30s
      retries: 5
      timeout: 10s
      start_period: 10s
    networks:
      - internal-network

Full docker-compose file

services:
  mysql-service:
    image: mysql:latest
    container_name: mysql-container
    environment:
      MYSQL_PASSWORD: 123123
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql  # create space for persistence data
      - ./database:/docker-entrypoint-initdb.d # Mount init file into container 
    healthcheck:  # Check every 10s to make sure it work fine
      test: ["CMD-SHELL", "mysqladmin -u root -p$MYSQL_PASSWORD ping -h localhost || exit 1"]
      interval: 30s
      retries: 5
      timeout: 10s
      start_period: 10s
    networks:
      - internal-network

  nginx:
    image: nginx:latest
    container_name: nginx-gateway
    ports:
      - "9099:9099"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro # Mount nginx config from local to container
    depends_on:        # Start condition
      - project-service
      - user-service
      - task-service
    networks:
      - internal-network   # Virtual network
  project-service:
    build:
      context: ./project-service
      dockerfile: Dockerfile
    container_name: project-service-container
    ports:
      - "8081:8081"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  user-service:
    build:
      context: ./user-service
      dockerfile: Dockerfile
    container_name: user-service-container
    ports:
      - "8082:8082"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network
  task-service:
    build:
      context: ./task-service
      dockerfile: Dockerfile
    container_name: task-service-container
    ports:
      - "8083:8083"
    environment:
      MYSQL_HOST: mysql-service
      MYSQL_PORT: 3306
      MYSQL_USER: root
      MYSQL_PASSWORD: 123123
    depends_on:
      mysql-service:
        condition: service_healthy
    networks:
      - internal-network # Virtual network

  client-service: 
    build:
      context: ./client-app
      dockerfile: Dockerfile
    container_name: client-app-container
    ports:
      - "80:80"
    restart: always # Auto restart when it fail

networks:
  internal-network:
      driver: bridge
      name: internal-network

volumes:
  mysql-data:

How to run

After finished docker-compose, open terminal and run

docker compose up -d

It will build, create, and start the services defined in a docker-compose.yml file for you.

Conclusion

In this post, I focused on the overall structure and main services. In an upcoming topic, I’ll dive deeper into how healthchecks, volumes, and networks work to further improve reliability and maintainability in your deployments.
Happy Coding !!!

Deploy microservice with Docker from scratch - P1

Luke — Sun, 20 Jul 2025 09:14:27 +0000

In this series, I will build and deploy a simple microservice app with docker. Everything begin from scratch 😎

Prerequisite

Installed Docker (If you don't have it, follow the instructions for Windows or Linux)

Tech stack

Right here, I will use:

FE: Angular
BE: Java
DB: MySQL

P/s: You can use your preferred stack, but scripting a docker-image build may differ slightly.

Architecture

The system will have 6 components:
1) Client app: Interact BE via API
2) Nginx (gateway): Reverse proxy and load balancer
3) Project Service: Handle request relate to project
4) Task Service: Handle request relate to task
5) User Service: Handle request relate to user
6) Database Layer (MySQL): Data persistence

Project Structure

/
├── client-app/ 
│   ├── src/
│   └── Dockerfile 
├── project-service/
│   ├── src/ 
│   └── Dockerfile 
├── task-service/ 
│   ├── src/
│   └── Dockerfile
├── user-service/ 
│   ├── src/
│   └── Dockerfile
├── docker-compose
└── nginx.conf

❗Important thing: Did you notice every service have each own Dockerfile 🤔

Docker file

FE (AngularJS)

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
COPY angular*.json ./
COPY tsconfig*.json ./
RUN npm install --legacy-peer-deps
COPY . .
RUN npm run build -- --configuration production

FROM nginx:alpine AS production
COPY --from=builder /app/dist/client-app/browser/ /usr/share/nginx/html

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

BE (Java)

FROM maven:latest AS build
WORKDIR /projectservice
COPY . .
RUN mvn clean package -DskipTests

FROM eclipse-temurin:21-jdk-alpine
WORKDIR /projectservice
COPY --from=build /projectservice/target/*.jar app.jar
EXPOSE 8081
ENTRYPOINT ["java", "-jar", "/projectservice/app.jar"]

As mentioned above, each service will have its own Dockerfile so remember clone and update it for each service.

Conclusion

Okay, I have an overview of the project and its functionality. In the next post, I'll delve into implementation details.

Happy Coding!!!

Install Docker on Linux

Luke — Sun, 20 Jul 2025 09:14:02 +0000

1) Update system

Make sure your system are using latest version of everything

sudo apt update
sudo apt upgrade -y

Install packages help apt download package via HTTPS

sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

2) Install Docker

Docker can be installed using either a quick method or a more detailed one.

The quick one

curl -fsSL https://get.docker.com/ | sh

Another way

Add Docker's GPG official

curl -fsSL https://download.docker.com/linux/ubuntu/gpg |sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Add Docker repository into APT source list

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list> /dev/null

Install Docker Engine

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y

3) Check Docker status

If it's fine, you'll see active (running) status

sudo systemctl status docker

4) Allow Docker run without `sudo`

sudo usermod -aG docker ${USER}
newgrp docker

5) Test Docker

If you see welcome message, it mean Docker install successfully

docker run hello-world

6) Install Docker Compose (Optional)

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose sudo chmod +x /usr/local/bin/docker-compose

Now your Linux system ready to go!
Happy Coding.