EC2 환경에서 Kubernetes를 직접 구축하는 방식은 AWS의 Managed Service인 EKS와 달리, 모든 구성 요소를 사용자가 직접 설치하고 제어해야 한다는 특징이 있습니다. 이러한 방식은 흔히 “Legacy Kubernetes” 또는 “kubeadm 기반 Self-managed Kubernetes”라고 부르며, Control Plane과 Worker Node를 모두 EC2 인스턴스 위에서 직접 구성하는 형태입니다.

이 글에서는 EC2 기반 Amazon Linux 2023 환경에서 kubeadm을 활용해 Kubernetes 클러스터를 구성하는 전체 과정을 다룹니다. Control Plane EC2 인스턴스를 초기화하고, Worker Node를 클러스터에 조인시키는 기본 구조부터 시작하여, Container Runtime 설정, CNI 네트워크 플러그인 설치, kubeconfig 구성까지 단계적으로 설명합니다.

또한 실제 운영 환경에서 중요한 네트워크 포트 설정, Security Group 구성, 그리고 클러스터 통신 구조까지 함께 다루어 단순 설치가 아닌 “동작하는 Kubernetes 클러스터”를 만드는 것을 목표로 합니다.

즉, EC2 기반 Legacy Kubernetes 구축은 관리형 서비스 없이도 Kubernetes를 직접 구성하고 운영할 수 있도록 해주는 가장 기본적이면서도 핵심적인 Self-managed 클러스터 구성 방식입니다.

Setup

Application

main.py

from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.get("/version")
def get_version():
    return {"version": "v1.0.0"}

@app.get("/healthcheck")
def get_healthcheck():
    return {"status": "ok"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8080)

해당 애플리케이션은 Pod의 동작을 확인하기 위한 테스트용 코드입니다.

requirements.txt

fastapi==0.136.1
uvicorn==0.46.0

Dockerfile

FROM python:3.14-alpine

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

WORKDIR /app
COPY ./main.py /app/main.py
COPY ./requirements.txt /app/requirements.txt

RUN apk add --no-cache curl && pip install --no-cache-dir -r requirements.txt && rm -rf /root/.cache/

RUN adduser -D --disabled-password --gecos '' app-user
USER app-user

EXPOSE 8080
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Practice

VPC

Public Subnet과 Private Subnet을 구성합니다. Availability Zone A와 C에 구성합니다.

Security Group

Bastion

Inbound

Outbound

ALB

Inbound

Outbound

Kubernetes Master Node

Inbound

Outbound

Kubernetes Worker Node

Inbound

Outbound

IAM

Kubernetes Node가 ECR 이미지를 Pull할 수 있도록 IAM Role을 생성하고 필요한 권한을 부여합니다.

Bastion

Kubernetes Node

EC2

Bastion

User Data

#!/bin/bash
dnf update -y
dnf upgrade -y
dnf install --allowerasing -y jq curl wget unzip vim

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

sed -i "s|PasswordAuthentication no|PasswordAuthentication yes|g" /etc/ssh/sshd_config
systemctl restart sshd
echo 'Skill53##' | passwd --stdin ec2-user
echo 'Skill53##' | passwd --stdin root

dnf install -y docker
systemctl enable --now docker
usermod -aG docker ec2-user
chmod 666 /var/run/docker.sock

Kubernetes Master Node

User Data

#!/bin/bash
dnf update -y
dnf upgrade -y
dnf install --allowerasing -y jq curl wget unzip vim

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

sed -i "s|PasswordAuthentication no|PasswordAuthentication yes|g" /etc/ssh/sshd_config
systemctl restart sshd
echo 'Skill53##' | passwd --stdin ec2-user
echo 'Skill53##' | passwd --stdin root

dnf install -y docker
systemctl enable --now docker
usermod -aG docker ec2-user
chmod 666 /var/run/docker.sock

Kubernetes Worker Node

User Data

#!/bin/bash
dnf update -y
dnf upgrade -y
dnf install --allowerasing -y jq curl wget unzip vim

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

sed -i "s|PasswordAuthentication no|PasswordAuthentication yes|g" /etc/ssh/sshd_config
systemctl restart sshd
echo 'Skill53##' | passwd --stdin ec2-user
echo 'Skill53##' | passwd --stdin root

ECR

ECR Registry를 생성합니다.

환경변수를 정의합니다.

ACCOUNT_ID=$(aws sts get-caller-identity --query "Account" --output text)
REGION_CODE="ap-northeast-2"
ECR_NAME="demo-ecr"
IMAGE_TAG="v1.0.0"
ECR_URI=$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com/$ECR_NAME

Docker 이미지를 Build 후 Push합니다.

aws ecr get-login-password --region $REGION_CODE | docker login --username AWS --password-stdin "$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com"
docker build -t "$ECR_URI:$IMAGE_TAG" .
docker push "$ECR_URI:$IMAGE_TAG"

Kubernetes

Master Node

Containerd Package를 설치합니다. Containerd는 컨테이너 런타임으로, kubelet이 컨테이너를 실행할 때 사용됩니다.

CONTAINERD_VERSION=$(curl -s https://api.github.com/repos/containerd/containerd/releases/latest | jq -r .tag_name)
curl -fsSLO https://github.com/containerd/containerd/releases/download/${CONTAINERD_VERSION}/containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz
sudo tar -C /usr/local -xzf containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz
rm -rf containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz

Containerd 서비스 파일이 위치할 디렉터리를 생성합니다.

sudo mkdir -p /usr/local/lib/systemd/system

Containerd 설정파일을 systemd에 다운로드 합니다.

sudo curl -sSL https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -o /usr/local/lib/systemd/system/containerd.service

systemd 설정을 다시 로드합니다.

sudo systemctl daemon-reload

Containerd를 실행합니다.

sudo systemctl enable --now containerd

runc Package를 설치합니다.

RUNC_VERSION=$(curl -s https://api.github.com/repos/opencontainers/runc/releases/latest | jq -r .tag_name)
curl -sSLO https://github.com/opencontainers/runc/releases/download/${RUNC_VERSION}/runc.amd64
sudo install -m 755 runc.amd64 /usr/local/sbin/runc
rm -rf runc.amd64

CNI 플러그인이 설치될 경로를 생성합니다.

sudo mkdir -p /opt/cni/bin

CNI Package를 설치합니다.

CNI_VERSION=$(curl -s https://api.github.com/repos/containernetworking/plugins/releases/latest | jq -r .tag_name)
curl -sSLO https://github.com/containernetworking/plugins/releases/download/${CNI_VERSION}/cni-plugins-linux-amd64-${CNI_VERSION}.tgz
sudo tar -C /opt/cni/bin -xzf cni-plugins-linux-amd64-${CNI_VERSION}.tgz
rm -rf cni-plugins-linux-amd64-${CNI_VERSION}.tgz

Kubernetes 패키지 저장소를 등록합니다.

sudo tee /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.35/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.35/rpm/repodata/repomd.xml.key
EOF

Kubernetes Package를 설치합니다.

kubeadm: 쿠버네티스 클러스터를 생성, 설정 및 초기화하는 구축 전용 도구
kubelet: 각 노드에서 실행되며 Pod의 컨테이너 상태를 관리하고 명령을 수행
kubectl: 사용자가 클러스터에 명령을 내리고 리소스를 제어하기 위해 사용하는 명령줄 도구

sudo dnf install -y kubeadm kubelet kubectl

패키지 버전을 고정할 수 있는 dnf 플러그인을 설치합니다.

sudo dnf install -y 'dnf-command(versionlock)'

Kubernetes Package의 버전을 고정합니다. (업데이트 방지)

sudo dnf versionlock add kubeadm kubelet kubectl

swap 메모리를 비활성화합니다.

sudo swapoff -a

재부팅 후에도 swap 메모리가 비활성화 되도록 설정합니다.

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

SELinux를 비활성화 합니다. (충돌 방지)

sudo setenforce 0

SELinux를 영구적으로 Permissive 모드로 설정합니다.

sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

Pod 네트워크 라우팅을 허용합니다.

sudo sh -c 'echo "net.ipv4.ip_forward=1" >> /etc/sysctl.conf'

sysctl 명령어를 사용하여 설정을 적용합니다.

sudo sysctl -p

kubelet을 자동 실행합니다.

sudo systemctl enable --now kubelet

Path를 설정합니다. (kubeadm 실행 오류 방지)

export PATH=$PATH:/sbin

EC2 MetaData 접근 토큰을 생성하며, 토큰을 사용하여 MetaData에서 EC2의 Private IP를 가져옵니다.

TOKEN=$(curl -sSX PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
PRIVATE_IP=$(curl -sS -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/local-ipv4)

Kubernetes를 초기화 합니다. 초기화 후 나온 kubeadm join 값을 저장합니다.

• 나중에 Worker Node에서 Master Node로 Join할 때 사용합니다.

만약, kubeadm join 값이 없어졌다면 아래 명령어를 사용하여 새로 발급받습니다.

sudo kubeadm token create --print-join-command

sudo PATH=$PATH:/sbin kubeadm init --apiserver-advertise-address=$PRIVATE_IP --pod-network-cidr=192.168.0.0/16

kubeconfig 파일을 생성합니다.

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Calico Package를 설치합니다.

CNI_VERSION=$(curl -s https://api.github.com/repos/projectcalico/calico/releases/latest | jq -r .tag_name)
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/$CNI_VERSION/manifests/calico.yaml

Pod의 상태가 Running인지 확인합니다.

kubectl get po -n kube-system

Node의 상태가 Ready인지 확인합니다.

kubectl get no

etcd Package를 설치합니다.

ETCD_VERSION=$(curl -s https://api.github.com/repos/etcd-io/etcd/releases/latest | jq -r .tag_name)
curl -sSLO https://github.com/etcd-io/etcd/releases/download/$ETCD_VERSION/etcd-$ETCD_VERSION-linux-amd64.tar.gz
tar xzf etcd-$ETCD_VERSION-linux-amd64.tar.gz
sudo mv etcd-$ETCD_VERSION-linux-amd64/etcdctl /usr/local/bin/
rm -rf etcd-$ETCD_VERSION-linux-amd64*

etcd Pod가 Running인지 확인합니다.

kubectl get po -n kube-system

etcd에서 사용하는 인증서(SSL/TLS 키 파일)이 존재하는지 확인합니다.

ls /etc/kubernetes/pki/etcd 

Secret을 생성합니다.

kubectl create secret generic demo-old-secrets --from-literal=key=topsecret

etcd 내부 저장값을 확인합니다. 암호화가 안되어 있어 평문으로 나오고 있음을 확인할 수 있습니다.

기본적으로 Kubernetes Secrets은 etcd에 평문(정확히는 단순 Base64 인코딩)으로 저장되어, DB 접근 권한이 있으면 누구나 내용을 확인할 수 있습니다.

sudo etcdctl \
   --cacert=/etc/kubernetes/pki/etcd/ca.crt \
   --cert=/etc/kubernetes/pki/etcd/server.crt \
   --key=/etc/kubernetes/pki/etcd/server.key \
   get /registry/secrets/default/demo-old-secrets | hexdump -C

Secret 암호화 설정 파일을 생성합니다. 이때 AES 암호화 알고리즘 중 CBC 모드를 사용하여 데이터를 암호화 합니다.

AES (Advanced Encryption Standard) 미국 표준 암호화로 대칭키 방식을 사용합니다. 데이터를 암호화할 때와 복호화할 때 동일한 키를 사용합니다.
CBC (Cipher Block Chaining) AES는 데이터를 한 번에 처리하지 않고 일정한 크기(블록)로 나누어 처리합니다. 이때 블록들을 어떻게 서로 엮어서 암호화할지 결정하는 방식이 바로 CBC입니다.

cat <<\EOF> enc.yaml
apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key
              secret: ENCRYPTION_KEY
      - identity: {} 
EOF

암호화 키를 생성합니다.

ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)

암호화키를 Secret 암호화 설정 파일에 삽입합니다.

sed -i "s|ENCRYPTION_KEY|$ENCRYPTION_KEY|g" enc.yaml

Secret 암호화 설정 파일이 위치할 디렉터리를 생성합니다.

sudo mkdir -p /etc/kubernetes/enc/

Secret 암호화 설정 파일을 위에서 생성한 디렉터리로 이동합니다.

sudo mv enc.yaml /etc/kubernetes/enc/

API Server의 설정 파일에서 아래 Encryption 설정을 추가합니다. 추가 후 저장하고 나가면 API Server가 자동으로 재시작됩니다.

sudo vim /etc/kubernetes/manifests/kube-apiserver.yaml

spec.containers[0].command

- --encryption-provider-config=/etc/kubernetes/enc/enc.yaml

spec.containers[0].volumeMounts

- name: enc
  mountPath: /etc/kubernetes/enc
  readOnly: true

spec.volumes

- name: enc
  hostPath:
    path: /etc/kubernetes/enc
    type: DirectoryOrCreate

Secret을 생성합니다.

kubectl create secret generic demo-new-secrets --from-literal=key=topsecret

etcd 내부 저장값을 확인합니다. 암호화가 되어 있는 것을 확인할 수 있습니다.

sudo etcdctl \
   --cacert=/etc/kubernetes/pki/etcd/ca.crt \
   --cert=/etc/kubernetes/pki/etcd/server.crt \
   --key=/etc/kubernetes/pki/etcd/server.key \
   get /registry/secrets/default/demo-new-secrets | hexdump -C

Secret 전체에 암호화가 적용되었는지 확인합니다.

kubectl get secrets --all-namespaces -o json | kubectl replace -f -

API Server가 실행중인지 확인합니다.

ps aux | grep kube-api

API Server에서 암호화가 적용되었는지 확인합니다.

ps aux | grep kube-api | grep encry

Worker Node

Containerd Package를 설치합니다.

CONTAINERD_VERSION=$(curl -s https://api.github.com/repos/containerd/containerd/releases/latest | jq -r .tag_name)
curl -fsSLO https://github.com/containerd/containerd/releases/download/${CONTAINERD_VERSION}/containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz
sudo tar -C /usr/local -xzf containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz
rm -rf containerd-${CONTAINERD_VERSION#v}-linux-amd64.tar.gz

Containerd 서비스 파일이 위치할 디렉터리를 생성합니다.

sudo mkdir -p /usr/local/lib/systemd/system

Containerd 설정파일을 systemd에 다운로드 합니다.

sudo curl -sSL https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -o /usr/local/lib/systemd/system/containerd.service

systemd 설정을 다시 로드합니다.

sudo systemctl daemon-reload

Containerd를 실행합니다.

sudo systemctl enable --now containerd

runc Package를 설치합니다.

RUNC_VERSION=$(curl -s https://api.github.com/repos/opencontainers/runc/releases/latest | jq -r .tag_name)
curl -sSLO https://github.com/opencontainers/runc/releases/download/${RUNC_VERSION}/runc.amd64
sudo install -m 755 runc.amd64 /usr/local/sbin/runc
rm -rf runc.amd64

Kubernetes 패키지 저장소를 등록합니다.

sudo tee /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.35/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.35/rpm/repodata/repomd.xml.key
EOF

Kubernetes Package를 설치합니다.

sudo dnf install -y kubeadm kubelet

패키지 버전을 고정할 수 있는 dnf 플러그인을 설치합니다.

sudo dnf install -y 'dnf-command(versionlock)'

Kubernetes Package의 버전을 고정합니다. (업데이트 방지)

sudo dnf versionlock add kubeadm kubelet

swap 메모리를 비활성화합니다.

sudo swapoff -a

재부팅 후에도 swap 메모리가 비활성화 되도록 설정합니다.

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

SELinux를 비활성화 합니다. (충돌 방지)

sudo setenforce 0

SELinux를 영구적으로 Permissive 모드로 설정합니다.

sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

Pod 네트워크 라우팅을 허용합니다.

sudo sh -c 'echo "net.ipv4.ip_forward=1" >> /etc/sysctl.conf'

sysctl 명령어를 사용하여 설정을 적용합니다.

sudo sysctl -p

kubelet을 자동 실행합니다.

sudo systemctl enable --now kubelet

Worker Node를 Master Node에 Join합니다. Master Node에서 kubeadm init 후 나온 값을 넣습니다.

만약, 해당 값을 잊어버렸다면 Master Node에서 아래 명령어 입력 후 나온 값을 넣어줍니다.

sudo kubeadm token create --print-join-command

sudo kubeadm join 10.0.2.135:6443 --token a5fwyw.t1nljbrukh3k6d2z \
  --discovery-token-ca-cert-hash sha256:85d09c2a09226d7c2678d178ce8c0ebcc1cd14ff0f4471bcc2b7e1e902b5bc49

Master Node

Worker Node가 Master Node에 정상적으로 Join 되었는지 확인합니다. Node의 상태가 Ready인지 확인합니다.

kubectl get no

Namespace를 생성합니다.

kubectl create ns demo

환경변수를 설정합니다.

ACCOUNT_ID=$(aws sts get-caller-identity --query "Account" --output text)
REGION_CODE="ap-northeast-2"

ECR에서 이미지를 할당 받을 수 있도록 ECR에 대한 Secrets를 생성합니다.

kubectl create secret docker-registry ecr-secret \
  --namespace=demo \
  --docker-server=$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com \
  --docker-username=AWS \
  --docker-password=$(aws ecr get-login-password --region $REGION_CODE)

Deployment 설정 파일을 생성합니다.

cat <<\EOF> deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-deploy
  namespace: demo
  labels:
    app: demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      imagePullSecrets:
      - name: ecr-secret
      containers:
      - name: demo-cnt
        image: IMAGE
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
EOF

이미지에 대한 환경변수를 설정합니다.

ECR_NAME="demo-ecr"
IMAGE_TAG="v1.0.0"
ECR_URI=$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com/$ECR_NAME

이미지를 ECR Registry에 업로드된 이미지로 변경합니다.

sed -i "s|IMAGE|$ECR_URI:$IMAGE_TAG|g" deployment.yaml

Deployment를 배포합니다.

kubectl apply -f deployment.yaml

Service 설정 파일을 생성합니다.

cat <<\EOF> service.yaml
apiVersion: v1
kind: Service
metadata:
  name: demo-svc
  namespace: demo
spec:
  selector:
    app: demo
  ports:
  - port: 8080
    targetPort: 8080
    nodePort: 30000
  type: NodePort
EOF

Service를 배포합니다.

kubectl apply -f service.yaml

Worker Node

curl http://localhost:30000/version

curl http://localhost:30000/healthcheck

정상적으로 API 호출이 되는 것을 확인할 수 있습니다.

ALB

Target Group

Target Group Port는 Service의 NodePort(30000)에 맞춰 Target Group Port를 동일하게 설정합니다.

Load Balancer

Test

ALB_NAME="demo-alb"
ALB_DNS=$(aws elbv2 describe-load-balancers --names $ALB_NAME --query "LoadBalancers[].DNSName" --output text)

curl $ALB_DNS/version

curl $ALB_DNS/healthcheck

정상적으로 API 호출이 되는 것을 확인할 수 있습니다.

Result

이번 실습을 통해 kubeadm을 활용하여 Kubernetes 클러스터를 직접 구성하는 전체 과정을 확인할 수 있었습니다. 기존에는 관리형 서비스 없이 Kubernetes 환경을 구축하기 위해 복잡한 설정과 수동 구성이 필요했지만, kubeadm을 사용하면 Control Plane과 Worker Node를 비교적 표준화된 방식으로 손쉽게 구성할 수 있습니다.

또한 containerd, CNI 플러그인, kubelet 등의 구성 요소를 직접 설치하고 설정함으로써 Kubernetes의 내부 구조와 동작 방식을 깊이 이해할 수 있었습니다. 특히 etcd, API Server, 그리고 네트워크 구성 요소 간의 관계를 실습을 통해 명확히 파악할 수 있었습니다.

더불어 Secret의 etcd 저장 구조와 Encryption 설정을 통해 Kubernetes의 보안 메커니즘까지 확인할 수 있었으며, NodePort 기반 서비스와 외부 접근 구성을 통해 실제 서비스 배포 흐름을 경험할 수 있었습니다.

이러한 과정은 관리형 Kubernetes(EKS 등)를 사용할 때는 보이지 않는 내부 동작을 이해하는 데 중요한 기반이 되며, 문제 해결 능력과 운영 역량을 향상시키는 데 큰 도움이 되었습니다.

Docker 이미지는 기본적으로 특정 CPU 아키텍처에 따라 만들어지기 때문에(ex: x86_64, ARM64 등) 서로 다른 환경에서 동일한 이미지를 실행하려고 하면 아키텍처 호환성 문제가 생길 수 있습니다. 최근에는 클라우드 환경, IoT 디바이스, 그리고 Apple Silicon처럼 여러 가지 플랫폼이 함께 사용되는 시대여서 이런 제약이 더욱 뚜렷하게 드러납니다.

이 글에서는 이러한 문제를 해결할 수 있도록 Docker의 멀티 아키텍처 이미지 구성 방법을 설명합니다. buildx를 사용해 여러 플랫폼용 이미지를 빌드하는 방법부터 manifest를 활용한 통합 이미지 관리 방법까지, 실제 따라 해볼 수 있는 예제를 중심으로 다룰 예정입니다. 이를 통해 하나의 이미지 태그만으로 다양한 아키텍처를 지원하는 과정을 이해하는 것이 목표입니다.

즉, 하나의 이미지를 여러 아키텍처 환경에서 그대로 사용하기 위해서는 멀티 아키텍처 이미지 구성이 필요합니다.

Setup

Application

package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime"
)

func arch(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Application Running\nARCH=%s\n", runtime.GOARCH)
}

func healthcheck(w http.ResponseWriter, req *http.Request) {
    fmt.Fprint(w, "OK")
}

func main() {
    http.HandleFunc("/arch", arch)
    http.HandleFunc("/healthcheck", healthcheck)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

해당 애플리케이션은 실행 중인 컨테이너의 CPU 아키텍처를 확인하기 위한 테스트용 코드입니다.

Dockerfile

FROM --platform=$BUILDPLATFORM golang:1.22-alpine AS builder

WORKDIR /build

ARG TARGETOS
ARG TARGETARCH
ENV CGO_ENABLED=0

COPY ./main.go ./

RUN go mod init noah.io/ark/rest && go mod tidy

RUN --mount=type=cache,target=/root/.cache/go-build \
    GOOS=$TARGETOS \
    GOARCH=$TARGETARCH \
    go build -trimpath -buildvcs=false -ldflags="-s -w" -o main main.go

FROM alpine:3.20

WORKDIR /app

RUN apk add --no-cache curl

COPY --from=builder /build/main .

EXPOSE 8080
ENTRYPOINT ["/app/main"]

• --platform=$BUILDPLATFORM : 빌드 환경 기준으로 builder 이미지 선택
• TARGETOS, TARGETARCH : buildx가 자동으로 전달하는 타겟 플랫폼 정보
• GOOS, GOARCH : 크로스 컴파일을 통해 다른 아키텍처용 바이너리 생성

Practice

ECR에 업로드 하는 Layer는 하나의 ECR Repository에서만 동작합니다.

Amazon ECR Registry를 생성합니다.

buildx Package를 설치합니다.

• Amazon Linux 사용 시 buildx Package 설치를 안해도 무방합니다.

  # AMD64
  mkdir -p ~/.docker/cli-plugins
  curl -L https://github.com/docker/buildx/releases/download/v0.33.0/buildx-v0.33.0.linux-amd64 -o ~/.docker/cli-plugins/docker-buildx
  chmod +x ~/.docker/cli-plugins/docker-buildx
  

ARM64

mkdir -p ~/.docker/cli-plugins curl -L https://github.com/docker/buildx/releases/download/v0.33.0/buildx-v0.33.0.linux-arm64 -o ~/.docker/cli-plugins/docker-buildx chmod +x ~/.docker/cli-plugins/docker-buildx

<br>

buildx Version을 확인합니다.
```shell
docker buildx version

환경변수를 입력합니다.

ACCOUNT_ID=$(aws sts get-caller-identity --query "Account" --output text)
REGION_CODE="ap-northeast-2"
ECR_NAME="demo-ecr"
ECR_URI="$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com/$ECR_NAME"
IMAGE_TAG="v1.0.0"

서로 다른 CPU 아키텍처 이미지를 빌드하기 위해서 tonistiigi/binfmt 컨테이너를 실행합니다.

docker run --privileged --rm tonistiigi/binfmt --install all

멀티 아키텍처 이미지를 빌드하기 위한 전용 빌더 환경을 생성합니다.

docker buildx create --name multi-builder --driver docker-container --use --bootstrap

ECR Registry에 로그인합니다.

aws ecr get-login-password --region $REGION_CODE | docker login --username AWS --password-stdin "$ACCOUNT_ID.dkr.ecr.$REGION_CODE.amazonaws.com"

CPU 아키텍처별로 Docker 이미지를 각각 따로 빌드합니다.

docker buildx build --platform linux/amd64 -t $ECR_URI:$IMAGE_TAG-amd64 --load .
docker buildx build --platform linux/arm64 -t $ECR_URI:$IMAGE_TAG-arm64 --load .

Amazon ECR에 Docker 이미지를 Push합니다.

docker push $ECR_URI:$IMAGE_TAG-amd64
docker push $ECR_URI:$IMAGE_TAG-arm64

Amazon ECR에 업로드한 Docker 이미지를 조회합니다. 조회 시 CPU 아키텍처별로 이미지가 업로드된 것을 확인할 수 있습니다.

aws ecr describe-images --repository-name $ECR_NAME --region $REGION_CODE

CPU 아키텍처 이미지를 하나로 만들기 위해서 멀티 아키텍처 이미지로 묶습니다.

• manifest는 실제 이미지를 합치는 것이 아니라, 각 아키텍처 이미지를 참조하는 메타데이터입니다.

  docker manifest create $ECR_URI:$IMAGE_TAG $ECR_URI:$IMAGE_TAG-amd64 $ECR_URI:$IMAGE_TAG-arm64

manifest에 각 이미지의 정확한 플랫폼 정보(OS/아키텍처)를 명시해줍니다.

docker manifest annotate $ECR_URI:$IMAGE_TAG $ECR_URI:$IMAGE_TAG-amd64 --os linux --arch amd64
docker manifest annotate $ECR_URI:$IMAGE_TAG $ECR_URI:$IMAGE_TAG-arm64 --os linux --arch arm64

멀티 아키텍처 manifest 안에 어떤 이미지들이 들어있는지 확인합니다.

docker manifest inspect $ECR_URI:$IMAGE_TAG

로컬에서 만든 멀티 아키텍처 manifest를 Amazon ECR에 업로드합니다.

docker manifest push $ECR_URI:$IMAGE_TAG

Test

docker run --platform=linux/amd64 -d -p 8080:8080 $ECR_URI:$IMAGE_TAG

docker run --platform=linux/arm64 -d -p 8080:8080 $ECR_URI:$IMAGE_TAG

동일한 이미지 태그를 사용하더라도 --platform 옵션에 따라 서로 다른 아키텍처의 컨테이너가 실행되는 것을 확인할 수 있습니다.

Result

이번 실습을 통해 Docker에서 멀티 아키텍처 이미지를 구성하는 전체 과정을 확인할 수 있었습니다.
기존에는 CPU 아키텍처(x86, ARM 등)가 다른 환경에서는 동일한 이미지를 사용할 수 없었지만, buildx와 manifest를 활용하면 하나의 이미지 태그로 여러 플랫폼을 동시에 지원할 수 있습니다.

이러한 방식은 클라우드 환경, CI/CD 파이프라인, 그리고 다양한 디바이스를 대상으로 하는 서비스에서 매우 중요한 요소이며, 단일 이미지 태그로 다양한 실행 환경을 지원할 수 있다는 점에서 운영 효율성과 확장성을 크게 향상시킬 수 있습니다.

Setting VMnet

Common Setting

패키지서버에서 패키지를 다운 받아야 하기 때문에 NAT인 VMnet0를 사용합니다.

vim /etc/vim/vimrc
set number

vim /etc/netplan/config.yaml
network:
  version: 2
  ethernets:
    ens33:
     dhcp4: true

apt update -y
apt upgrade -y

apt install -y net-tools

IP Setting

패키지 설치 후 해당 머신에 맞는 VMnet으로 변경합니다.

[Client_A]

echo 'client-a' > /etc/hostname

vim /etc/netplan/config.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      addresses: [192.168.10.254/24]
      routes:
        - to: default
          via: 192.168.10.1

netplan apply

[Client_B]

echo 'client-b' > /etc/hostname

vim /etc/netplan/config.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      addresses: [192.168.10.254/24]
      routes:
        - to: default
          via: 192.168.10.1

netplan apply

[Server_A]

echo 'server-a' > /etc/hostname

vim /etc/netplan/config.yaml                                                                    
network:
    version: 2
  ethernets:
        ens33:
            addresses: [192.168.10.1/24]
        ens36:
            addresses: [10.0.0.1/24]
            routes:
                - to: 10.0.1.0/24
                    via: 10.0.0.1

netplan apply

[Server_B]

echo 'server-b' > /etc/hostname

vim /etc/netplan/config.yaml
network:
    version: 2
    renderer: networkd
    ethernets:
        ens33:
            addresses: [192.168.20.1/24]
        ens36:
            addresses: [10.0.1.1/24]
            routes:
                - to: 10.0.0.0/24
                    via: 10.0.1.1

netplan apply

Setting Site-to-Site VPN

[Server_A]

apt install -y strongswan

systemctl enable --now ipsec

vim /etc/ipsec.conf    
conn s2s
    type=tunnel
    left=10.0.0.1
    leftsubnet=192.168.10.0/24
    right=10.0.1.1
    rightsubnet=192.168.20.0/24
    keyexchange=ikev2
    authby=secret
    leftauth=psk
    rightauth=psk
    auto=start
    ike=aes128-sha1-modp2048
    ikelifetime=28800
    esp=3des-md5-modp2048
    lifetime=3600
    compress=no
    keyingtries=%forever

vim /etc/ipsec.secrets
10.0.0.1 10.0.1.1 : PSK "S2S"

systemctl restart strongswan-starter

ipsec statusall

[Server_B]

apt install -y strongswan

systemctl enable --now ipsec

vim /etc/ipsec.conf
conn s2s
    type=tunnel
    left=10.0.1.1
    leftsubnet=192.168.20.0/24
    right=10.0.0.1
    rightsubnet=192.168.10.0/24
    keyexchange=ikev2
    authby=secret
    leftauth=psk
    rightauth=psk
    auto=start
    ike=aes128-sha1-modp2048
    ikelifetime=28800
    esp=3des-md5-modp2048
    lifetime=3600
    compress=no
    keyingtries=%forever

vim /etc/ipsec.secrets
10.0.0.1 10.0.1.1 : PSK "S2S"

systemctl restart strongswan-starter

ipsec statusall

Result

[Client_A]

ping 192.168.20.254 -c 4

tcpdump -p icmp -n

[Client_B]

ping 192.168.10.254 -c 4

tcpdump -p icmp -n

Uncomplicated Firewall의 약자로 Ubuntu 및 Debian 계열의 리눅스 배포판에서 간편하게 방화벽을 관리할 수 있도록 설계된 도구이며, Netfilter 기반의 iptables를 쉽게 다룰 수 있도록 만든 명령어

Command

Install Package

apt install -y ufw

기본 명령어

ufw enable

ufw 활성화

ufw disable

ufw 비활성화

ufw status verbose

ufw 상태 확인

ufw reset

룰 초기화

규칙 추가

ufw allow [Port]

Port 허용

ufw allow [Port]/[Protocol]

Port, Protocol 허용

ufw allow proto [Protocol] from any to any port [Port]

Port, Protocol 허용

ufw allow from [IP_Address]

특정 IP에서 들어오는 모든 트래픽 허용

ufw allow from [IP_Address]/[Prefix]

특정 Subnet에서 들어오는 트래픽 허용

ufw allow in on [Network_Interface]

Network Interface에서 들어오는 모든 트래픽 허용

규칙 삭제

ufw delete allow [Port]

Port 허용 규칙 삭제

ufw delete allow from [IP_Address]

특정 IP에서 오는 허용 규칙 삭제

ufw status numbered

번호가 있는 규칙 목록 확인

ufw delete [Number]

Number 규칙 삭제

트래픽 차단

ufw deny [Port]

Port 차단

ufw deny from [IP_Address]

특정 IP에서 오는 모든 트래픽 차단

ufw deny in on [Network_Interface]

Network Interface에서 들어오는 모든 트래픽 차단

ufw deny proto [Protocol] from any to any port [Port]

Port, Protocol 차단

vim /etc/ufw/before.rules
-A ufw-before-input -p icmp --icmp-type destination-unreachable -j ACCEPT
-A ufw-before-input -p icmp --icmp-type source-quench -j ACCEPT
-A ufw-before-input -p icmp --icmp-type time-exceeded -j ACCEPT
-A ufw-before-input -p icmp --icmp-type parameter-problem -j ACCEPT
-A ufw-before-input -p icmp --icmp-type echo-request -j ACCEPT

ICMP 허용 ACCEPT 부분을 DROP으로 변경 시 ping 요청이 거부됨.

로그 관리

ufw logging on

방화벽 로그 활성화

ufw logging off

방화벽 로그 비활성화

ufw logging low

최소한의 로그 기록

ufw logging medium

기본 로그 기록

ufw logging high

상세한 로그 기록

ufw logging full

모든 트래픽 로그 기록

기본 정책 설정

ufw default deny incoming

기본적으로 모든 들어오는 트래픽 차단

ufw default allow outgoing

기본적으로 모든 나가는 트래픽 허용

ufw default deny outgoing

기본적으로 모든 나가는 트래픽 차단

ufw default allow incoming

기본적으로 모든 들어오는 트래픽 허용

애플리케이션별 방화벽 설정

ufw app list

UFW가 관리하는 애플리케이션 목록 확인

ufw app info [Service_Name]

Service의 방화벽 설정 확인

ufw allow [Service_Name]

Service 허용

1. Table

• 패킷 필터링을 적용할 룰셋을 포함하는 컨테이너 역할
• 패킷을 처리할 Chain을 포함

2. (Chain)

• 트래픽이 특정 조건을 만족할 경우 수행할 규칙(룰)의 모음
• 체인은 hook을 통해 커널 네트워크 스택에 연결됨

3. Rule

• 특정 조건을 만족하는 패킷에 대해 실행할 동작을 정의

4. Set

• 여러 개의 IP 주소, 포트 번호 등을 그룹화하여 관리 가능

5. Map

• 특정 값과 대응되는 다른 값을 매핑하여 관리 가능

Nftables Chain & Hook

Command

Install Package

apt install -y nftables
systemctl enable --now nftables

Basic Structure

nft add rule [family] [table] [chain] ip saddr [Source] sport [Source_Port] ip daddr [Destination] dport [Destination_Port] [Action]

Command

nft add table ip [Table_Name]

Table 생성 (대소문자 구별함)

nft add chain ip [NAT] [Chain_Name] { type [Type] hook [postrouting] priority [Priority_Number] \; }

Additional Description

nft list tables

테이블 조회

nft table ip [Table_Name]

nft add rule ip [Table_Name] [Chain_Name] ip saddr [Source_IP] ip daddr [Destination_IP] counter [Action]

ntf insert rule ip [Table_Name] input [Protocol] dport [Destination_Port] counter accept

단일 Port 필터링

ntf insert rule ip [Table_Name] input [Protocol] dport {[Destination_Port], [Destination_Port]} counter accept

멀티 Port 필터링

• Packet Filtering
• State Insepction
• Application Gateway - OSI 7 Layer

Chain 기능

Filter Rule

• INPUT: 패킷이 서버로 들어오는 경우 > Linux 서버가 목적지인 패킷 (패킷이 서버로 들어옴)

• OUTPUT: 서버에서 패킷이 외부로 나가는 경우 > Linux 서버에서 외부 목적지로 나가는 패킷 (서버의 패킷이 외부로 나감)

• FORWARD: 패킷이 서버를 지나가는 경우 (INPUT & OUTPUT) > Source or Destination도 아닌 거쳐가는 경우 (NAT 네트워크 공유 기능을 위해 사용됨)

NAT Rule

• PREROUTING
  • DNAT(Destination NAT) 룰 적용
  • 패킷의 도착지 주소를 변경
• POSTROUTING
  • SNAT(Source NAT) 또는 masquerad 룰 적용
  • 패킷의 출발지 주소를 변경

iptables Table & Chain

Iptables Chain & Hook

Chain Strcture

iptables 구조도

Command

Install Package

apt install -y iptables iptables-persistent
systemctl enable --now iptables

Basic Structure

iptables [Access_Option] INPUT -s [Soure] --sport [Source_Port] -d [Destination] --dport [Destination_Port] -j [Policy]

Iptables Default Policy Access Option

Iptables Access Option

Target

Setting DHCP

DHCP Server

apt install -u isc-dhcp-server

vim /etc/dhcp/dhcpd.conf

option domain-name "<Domain Name>";
option domain-name-servers <Name Server IP Address>;

subnet 192.168.0.0 netmask 255.255.255.0 {
    range 192.168.0.2 192.168.0.254;
}

vim /etc/default/isc-dhcp-server
INTERFACESv4="ens33"
INTERFACESv6="ens33"

ifconfig ens33 192.168.0.1

systemctl restart isc-dhcp-server

dhcp-lrease-list

Client

vim /etc/netplan/00-installer-config.yaml

network:
  ethernets:
    ens33:
      dhcp4: true
  version: 2

netplan apply

DHCP Relay Server

apt install -y isc-dhcp-server
apt install -y isc-dhcp-relay

vim /etc/dhcp/dhcpd.conf

option domain-name-servers <Name Server IP Address>;


subnet 192.168.0.0 netmask 255.255.255.0 {
    range 192.168.0.2 192.168.0.254;
    option routers 192.168.0.1;
    interface ens33;
}

vim /etc/default/isc-dhcp-server
INTERFACESv4="eth1"

systemctl restart isc-dhcp-server

vim /etc/default/isc-dhcp-relay
SERVICES="<Network Interface IP Address>"
INTERFACESv4="ens33"

systemctl restart isc-dhcp-relay

Router

vim /etc/default/isc-dhcp-relay
INTERFACES="eth1 eth2"

systemctl restart isc-dhcp-relay

Trouble Shooting

아래는 App Armor Error이다.
Can't open /var/lib/dhcp/dhcpd.leases for append

vim /etc/default/grub
GRUB_CMDLINE_LINUX="apparmor=0"

update-grub

reboot

systemctl stop apparmor
sytsemctl disable apparmor

Domain Name System의 약자로 호스트의 도메인을 호스트의 네트워크 주소로 변환해주는 것

DNS 구성 요소

1. Domain Name System
2. Name Server
3. Resolver

DNS Record

Setting DNS

Forward

apt install -y bind9 bind9-utils bind9-dnsutils

vim /etc/resolv.conf
nameserver 192.168.0.1

vim /etc/bind/named.conf
zone  "naver.com"{
    type master;
    file "naver.zone";
};

vim /etc/bind/named.conf.options
dnssec-validation no;

cp /etc/bind/db.local /var/cache/bind/naver.zone

vim /var/cache/bind/naver.zone
:%s/localhost/ns.naver.com/g
       IN    A    192.168.0.1
ns    IN    A    192.168.0.1
www    IN    A    192.168.0.2

systemctl restart bind9

Lookup

apt install -y bind9 bind9-utils bind9-dnsutils

vim /etc/resolv.conf
nameserver 192.168.0.1

vim /etc/bind/named.conf
zone  "0.168.192.in-addr.arpa"{
    type master;
    file "naver.re.zone";
};

vim /etc/bind/named.conf.options
dnssec-validation no;

cp /etc/bind/db.local /var/cache/bind/naver.zone

vim /var/cache/bind/naver.zone
:%s/localhost/ns.naver.com/g
       IN    A    192.168.0.1
ns    IN    A    192.168.0.1
www    IN    A    192.168.0.2

cp /etc/bind/db.local /var/cache/bind/naver.re.zone

vim /var/cache/bind/naver.re.zone
:%s/localhost/ns.naver.com/g
1   IN    PTR ns.naver.com.

systemctl restart bind9

Master & Slave Master

apt install -y bind9 bind9-utils bind9-dnsutils

vim /etc/resolv.conf
nameserver 192.168.0.1
search example.com
domain example.com

vim /etc/bind/named.conf
zone  "example.com" {
    type master;
    file "example.zone";
    allow-update { any; };
    allow-transfer { 192.168.0.2; };
};

zone  "0.168.192.in-addr.arpa" {
    type master;
    file "example.re.zone";
    allow-update { any; };
    allow-transfer { 192.168.0.2; };
};

vim /etc/bind/named.conf.options
dnssec-validation no;

cp /etc/bind/db.local /var/cache/bind/example.zone

vim /var/cache/bind/example.zone
:%s/localhost/Master.example.com/g
Master IN    A    192.168.0.1
ns       IN    A    192.168.0.1
www       IN    A    192.168.0.2

cp /etc/bind/db.local /var/cache/bind/naver.re.zone

vim /var/cache/bind/example.re.zone
:%s/localhost/ns.naver.com/g
1  IN    PTR    ns.example.com.

systemctl restart bind9

Slave

apt install -y bind9 bind9-utils bind9-dnsutils

vim /etc/resolv.conf
nameserver 192.168.0.2
search example.com
domain example.com

vim /etc/bind/named.conf
zone  "example.com" {
    type slave;
    masters { 192.168.0.1; };
    file "example.zone";
};

zone  "0.168.192.in-addr.arpa" {
    type slave;
    masters { 192.168.0.1; };
    file "example.re.zone";
};

systemctl restart bind9

Ubuntu 17.10 (Artful Aardvark)부터 기본 네트워크 설정 도구로 도입되었습니다. 이전까지 Ubuntu는 ifupdown과 /etc/network/interfaces 파일을 사용했지만, 관리가 어려워지고 Cloud 환경에서 자동화된 설정이 필요해지면서 Netplan으로 전환되었습니다.

Netplan의 사용해야 하는 이유

• YAML 기반 설정
• 자동화 및 클라우드 친화적 (서버 및 컨테이너 환경에 적합)
• 유연한 렌더러 지원 (systemd-networkd (Server) / Netowkrn Manager (Desktop)
• 빠른 적용 및 테스트 기능

Netplan 기본 동작 방식

1. /etc/netplan/*.yaml | 설정 파일 작성
2. netplan generate | 백엔드용 설정 파일 생성
3. netplan apply | 네트워크 인터페이스 재시작 및 적용

Netplan Structure

DHCP

network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: true

Static IP

network:
  ethernets:
    ens33:
      addresses: 
        - <IP Address>/<Subnet Mask>
      gateway4: <Gateway IP Addaress>
      nameservers:
        addresses:
            - <DNS Server IP Address>
  version: 2

VLAN

network:
  ethernets:
    ens33:
      dhcp4: no
  vlans:
    <VLAN Name>:
      id: <VLAN Number>
      link: <Netowkr Interface>
      addresses:
        - <IP Address>/<Subnet Mask>
      gateway4: <Gateway IP Addaress>
  version: 2

Routing

Default Routing

network:
  renderer: networkd
  ethernets:
    ens33:
      addresses:
        - <IP Address>/<Subnet Mask>
      routes:
        - to: 0.0.0.0/0
          via: <IP Address>
  version: 2

via: 적용할 IP 주소

Static Routing

network:
  renderer: networkd
  ethernets:
    ens33:
      addresses:
        - <IP Address>/<Subnet Mask>
      routes:
        - to: <IP Address>/<Subnet Mask>
          via: <IP Address>
  version: 2

to: 적용할 네트워크 대역
via: 적용할 IP 주소

AWS Lambda는 다양한 분야에서 사용하는 코드형 기반 서버리스 서비스입니다. 하지만 Lambda는 Cold Start라는 초기 지연 시간이 발생할 수 있는데, Cold Start는 지연시간을 발생할 수 있습니다.

What is Lambda Cold Start?

AWS Lambda를 실행하면 바로 함수가 실행되지 않습니다.

Lambda 실행 시 Lambda에 올려둔 코드를 이미지 형태로 다운 받아 실행하며, 이후 컨테이너가 유지됩니다.

하지만 Lambda는 컨테이너 생성 후 5분동안 사용하지 않으면 사용하던 컨테이너가 중지되며, 종료됩니다.

이에 람다는 경우에 따라 초기 응답이 늦어지는 것을 Cold Start라고 합니다.

언어 및 코드에 따라 Cold Start 시간이 다르게 나타납니다.

위 사진처럼 Python, Node.js 같은 경우 상당히 빠르지만, C#, JAVA는 느립니다.

How Lambda Works?

1. Lambda Event 처리 방법 (Work Flow)

외부로부터 어떤 이벤트(요청)가 들어왔을 때 다음과 같은 순서로 이벤트를 처리합니다.

1) 실행환경 (컨테이너) 준비합니다.

• 컨테이너에 코드를 다운 받습니다.
• Lambda에 설정된 Memory, Runtime, Configuration 기반으로 환경 설정합니다.

2) 초기화 코드 (Init Code)를 실행합니다.

3) Lambda 함수 코드 (Event Handler)를 실행하여 이벤트를 처리합니다.

1번부분에서는 비용이 발생하지 않지만 람다 컨테이너가 실행될 때까지 해당부분에서도 Latency가 발생합니다. 2, 3번은 Lambda가 실제로 실행되는 시간이므로 비용이 발생합니다. 다만, Initialization Code 부분의 경우, 첫 번째 이벤트에 대해서만 실행되는 코드이며, 두번째 호출부터는 실행되지 않습니다. 따라서 2번도 Cold Start에 포함됩니다.

2. Lambda Life Cycle

Lambda는 총 3단계의 Life Cycle을 가집니다.

1) Init 단계 위에서 언급한 Cold Start가 해당 부분에 속합니다. 새로운 실행환경(컨테이너)를 요청하여 준비된 실행환경(컨테이너)가 람다 함수 코드를 다운로드 받고, 사용자가 람다 함수를 생성했을 때 지정해둔 Runtime, Memory, Configuration 등을 세팅하는 과정입니다. 또한, 람다 함수 코드에서 init code부분(라이브러리 및 global 변수 세팅)을 실행합니다.

2) Invoke 단계 실제 람다 함수 핸들러가 호출되어, 코드가 실행되는 단계입니다. 하나의 Request(Event)에 대한 처리가 완료되면, 람다는 다음 Request(Event)를 처리할 준비를 합니다.

3) Shutdown 단계 람다 함수 실행을 위해 세팅되어 있던 실행환경(컨테이너)가 죽는 단계입니다. 람다 함수는 일정 기간동안 호출을 받지 않으면 런타임을 종료하고 실행환경(컨테이너)을 제거합니다.

3. Lambda 통신 과정

1) Sequential 외부에서 어떠한 요청이 들어오면, Lambda는 새로운 실행환경(컨테이너)을 띄우고, 해당 실행환경에서 람다 함수의 코드를 실행할 수 있도록 이벤트를 발생시킵니다. 이 때, 하나의 컨테이너는 하나의 이벤트만 처리할 수 있으며, 해당 컨테이너가 이벤트를 처리하는 동안 freeze 상태가 됩니다.

이벤트 처리가 완료되면, 해당 컨테이너는 idle 상태가 됩니다. 이때, 아래 2개의 상태가 오래 지속되면 해당 컨테이너는 Shutdown 됩니다.

• 컨테이너가 idle 상태가 오래 지속되면 Shutdown됩니다.
• 요청받은 Request(이벤트)가 오래 지속되면 폐기 후 Shutdown됩니다.

2) Concurrent 위에서 언급한 바와 같이, 하나의 실행환경(컨테이너)은 한 번에 하나의 Request(Event)만 처리합니다. 따라서 Request(Event)를 처리하는 동안 해당 실행환경(컨테이너)은 freeze 상태가 됩니다.

이 때, 만약 실행환경(컨테이너)들이 전부 freeze상태임에도 불구하고 새로운 Request(Event)가 계속해서 들어오는 경우, 람다는 새로운 실행환경(컨테이너)을 가져오도록 트리거합니다. (즉, 새로운 인스턴스를 생성합니다.) concurrent하게 처리할 Request(Event)들에 대해 실행환경(컨테이너)는 계속해서 생성됩니다.

Lambda 실행에 따른 문제점

1. 새로운 실행환경(컨테이너)을 트리거하고 준비할 때마다 Cold Start를 겪어야 합니다. Lambda 함수마다 Concurrent 인스턴스 용량을 할당할 수 있도록 Reserved Concurrency와 Provisioned Concurrency를 설정할 수 있도록 되어있습니다.

2. Concurrent하게 띄울 수 있는 실행환경(컨테이너) 수에 Limit이 존재합니다. Region 별 Concurrent Instance 할당량은 1000개에서 시작합니다. AWS Service Quotas을 통해 해당 Limit을 증가시킬 수 있습니다.)

Cold Start 해결 방안

1. 적절한 런타임을 선택합니다. (언어마다 처리속도가 다르므로, 가능한 빠른 환경을 실행하는 것이 좋습니다. / Python, Node.js 등)
2. 자체적인 Warm Starat로 구성하기
3. Lambda Memory 사양을 늘립니다.
4. Provisioned Concurrency를 사용합니다.
5. 지속적으로 트래픽이 들어오게 설정합니다. (5~15분이 끝나기 전인 4분 59초 ~ 14분59초에 컨테이너가 반복적으로 실행되게 구성합니다.)
6. 코드를 최적화합니다.
7. 초기화 코드를 최소화합니다. (초기화 시 필요한 작업만 수행하도록 코드 구조를 최적화합니다. / 불필요한 글로벌 변수나 라이브러리 로딩을 피합니다.)
8. 테스트 및 모니터링합니다. (Lambda 함수의 성능을 지속적으로 모니터링하여, Cold Start가 발생 패턴을 파악하고 이를 기반으로 최적화합니다. AWS CloudWatch를 통해 지연 시간 및 Cold Start 빈도를 확인할 수 있습니다.
9. 여러 리전을 사용합니다. (트래픽이 높은 Application의 경우, 여러 AWS Region에서 Lambda 함수를 운영하여 부하분산시키고 Cold Start 빈도를 줄입니다.)

• MySQL Server 8.0.36 - x64
• MySQL Workbench 8.0.36 - x64
• MySQL Shell 8.0.36 - x64

8. Execute를 선택합니다.

9. 그 후 Next를 눌러 작업을 완료합니다.

10. Port 및 Protocol Port를 설정합니다.

    MySQL Default Port는 3306입니다.

11. Next를 선택합니다.

12. Password를 설정 후 Next 및 Execute를 선택합니다.

    Default User는 Root입니다.

13. 모든 작업이 완료되면 Finish 및 Next를 선택합니다.

1. VSCode 접근 후 아래 패키지를 다운로드합니다.

• Spring Boot Extension Pack
• thymeleaf

해당 Installer는 Windows에만 해당하고, 나머지 OS에서는 VSCode, JDK, Extensions Pack을 각각 설치해야합니다.

2. [Ctrl] + [Shift] + [P] 혹은 상단 메뉴 [View] > [Command Palette]를 실행하여, Spring Initializr를 입력합니다.

Spring Boot Version : 3.34 Language : Java Group ID : 원하는 그룹 ID Artifact ID - 원하는 Artifact ID Package Type : jar Java Version : 사용자가 설치한 Java 버전

3. 아래 Package를 찾아 설정합니다.

• Spring Boot DevTools
• Lombok
• Spring Boot Web
• Thymmeleaf

4. 모든 작업이 완료되면 아래 사진과 같이 생성된 프로젝트를 확인하실 수 있습니다.

Spring Boot 실행

1. 아래 명령어를 입력하여 생성된 Project를 Gradlew를 사용하여 Complie합니다.

   ./gradlew

   해당 명령어는 상대경로 기준으로 실행하며, 실행 시 Java를 Complie하여 Jar를 생성합니다.

2. 아래 명령어 입력 후 해당 Project를 실행합니다.

   ./gradlew bootRun

   해당 명령어는 상대경로 기준으로 실행됩니다.

1. VSCode 접근 후 아래 패키지를 다운로드합니다.

해당 Installer는 Windows에만 해당하고, 나머지 OS에서는 VSCode, JDK, Extensions Pack을 각각 설치해야합니다.

VSCode 에서 제공하는 Installer 다운로드 링크

2. Java 파일을 실행합니다.

3. 다운받은 파일을 압축을 해제 후 폴더 이름을 java로 변경합니다.

4. java 폴더를 아래 경로로 이동시켜줍니다.

   C:\

   

5. 환경변수를 등록해줍니다.

   제어판\모든 제어판 항목\시스템

   

6. CMD, PowerShell, GitBash등에 접속하여 실행이 되는지 테스트 합니다.

• java
• javac
• java -version
• javac -version

4. 오른쪽 상단에 [Generate new token] 선택박스를 클릭 후 [Generate new token (classic)]을 클릭합니다.

5. Note 및 Expiration을 입력합니다. (Note는 Token의 이름이며, Expiration은 만료일을 의미합니다.)

6. 생성된 Token을 기록 후 사용합니다.

CodeCommit Repository를 Linux 및 Window 환경에 Pull 하려고 할 시 아래와 같은 에러가 발생합니다.

fatal: unable to access 'https://git-codecommit.<Region>.amazonaws.com/v1/repos/<Repository Name>/': The requested URL returned error: 403

해당 에러가 발생하는 이유는 CodeCommit에대한 Pull 자격증명 권한이 삭제되었거나 잘못되었을 때 발생하는 에러입니다.

Trouble Shooting

기존에 있던 Git Credential을 삭제한 후 다시 진행하면 정상적으로 실행됩니다.

Window + R

해당 git://https://git-codecommit.ap-northeast-2.amazonaws.com 이라는 자격증명을 삭제한 후 다시 Git Credential을 진행할 시 위와 같이 해결됩니다.

경로는 아래와 같습니다.

제어판\사용자 계정\자격 증명 관리자

AWS Time Sync Service

AWS Time Sync Service란? AWS에서 제공하는 시간 동기화 서비스

169.254.139.123 IP 주소를 링크를 통해 서비스에 액세스 할 수 있습니다. 즉, 외부 인터넷 액세스를 구성할 필요 없이 프라이빗 서브넷 내에 안전하게 액세스할 수 있습니다.

Setting AWS Time Sync Service

Amazon Linux

sudo yum erase ntp*
sudo yum install -y chrony
sudo systemctl enable --now chronyd

또는 아래 줄을 추가하여 NTP Config를 수정하여 사용할 수 있습니다.

server 169.254.169.123 prefer iburst

Window

net stop w32time
w32tm /config /syncfromflags:manual /manualpeerlist:"169.254.169.123"
w32tm /config /reliable:yess
net start w32time

AWS Domain Server IP

AWS에서 DHCP Option 세트를 설정할 때 DNS Server의 IP를 지정하여야 합니다. DNS Server IP는 VPC Network 범위에 2를 더한 값입니다.

예시는 다음과 같습니다. VPC CIDR 범위 : 10.0.0.0/16

10.0.0.0 + 2 = 10.0.0.2

따라서 VPC DNS Server IP는 10.0.0.2 주소를 가지게 됩니다.

EC2 Instance DNS

EC2 Instance에서 /etc/resolve.conf에서 Domain Server IP와 같은 값인걸 확인할 수 있습니다. (해당 EC2 Instance는 VPC CIDR 10.0.0.0/16 대역에 존재합니다.)

sudo viㅡ /etc/ssh/sshd_config

#Port 22 부분을 수정해줍니다. (주석도 지워줍니다.)

Port <port>

systemctl restart sshd

shell script

Change to SSH Port in Shell Script - sed

sed -i "s|#Port 22|Port <port>|g" /etc/ssh/sshd_config
systemctl restart sshd

Change to SSH Port in Shell Script - echo

echo "Port <port>" >> /etc/ssh/sshd_config
systemctl restart sshd