Jenkins

Jenkins 설치하기

실습 환경

Ncloud Server High-CPU c2-g2-h50 CPU: 2EA, Memory: 4GB, Disk: 50GB

Java 17 설치

Jenkins는 Java 11이상에서 지원하지만 필자는 Spring Boot 3를 사용하여 Java 17로 설치한다

yum install -y java-17-openjdk-devel.x86_64

# java-17-openjdk.x86_64에 맞는 번호 선택
/usr/sbin/alternatives --config java

# java-17 환경 변수 추가
readlink -f $(which java)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-devel-17.0.9.0.9-2.el8_8.x86_64
source /etc/profile

Jenkins 설치

wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

yum install -y jenkins

# default port가 8080이므로 tomcat과 같은 VM을 사용한다면 겹치지 않도록 다른 포트번호를 주자
# 만약 실습과정에서 was 서버와 jenkins 서버를 분리해서 행할경우 생략해도 좋다
sed -i 's/Environment="JENKINS_PORT=8080"/Environment="JENKINS_PORT=18080"/' /usr/lib/systemd/system/jenkins.service

systemctl enable --now jenkins

주의사항 rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key 해당 경로는 만료된 Key로 Jenkins 설치가 안되니 블로그 검색 시 유의하자

로그인 및 세팅

비밀번호 확인

cat /var/lib/jenkins/secrets/initialAdminPassword

로그인

Install Suggested plugins

Create user Skip

admin 계정을 사용할 것이므로 Skip한다

접속한 url 입력

설치 및 로그인 완료

Password, Theme, Timezone 변경(선택)

GitLab

GitLab 설치하기

실습 권장 사양

• CPU: 2EA
• Memory: 8GB

  필수 종속성 설치

  yum install -y openssh-server policycoreutils-python-utils python3-policycoreutils curl perl

  GitLab 설치가 가능한 상태인지 확인 스크립트 실행

  curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | bash

  GitLab-CE 설치

  EXTERNAL_URL="http://{server-IP}:8088" yum install -y gitlab-ce

  GitLab root 비밀번호 확인

  cat /etc/gitlab/initial_root_password | grep Password:

  

  GitLab 로그인

  GitLab 비밀번호 변경

  

  GitLab Project 생성

  Git Lab 세팅 완료 후 Git Hub Repository와 똑같은 방식으로 사용하면 된다

아키텍처

Kubernetes cluster 및 아키텍처 구축

공통

1. 준비

1. 머신 성능 [최소 성능] RAM: 2GB CPU: 2 Core
   
2. 인스턴스 준비 [최소 개수] Master Node: 1 Worker Node: 2
   
3. Registry, Redis, MariaDB 준비
   1. Docker Registry
   2. Redis !!! 만약 redis 서버가 netstat -nlpt 에서 127.0.0.1:6379로 바인딩 돼있으면 외부통신이 불가하므로 /etc/redis.conf 파일에서  bind 0.0.0.0으로 수정하고 restart 해주자
   3. MariaDB

2. 리눅스 내부 세팅

1. hosts 설정

     cat <<EOF | tee /etc/hosts
     10.10.100.6 ldk-k8s-master
     10.10.100.7 ldk-k8s-worker1
     10.10.100.11 ldk-k8s-worker2

2. SELinux disable

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

3. 모듈 로드

     cat <<EOF | tee /etc/modules-load.d/k8s.conf
     overlay
     br_netfilter
     EOF
   
     modprobe overlay
     modprobe br_netfilter

4. cluster network set

     cat <<EOF | tee /etc/sysctl.d/k8s.conf
     net.bridge.bridge-nf-call-iptables = 1
     net.bridge.bridge-nf-call-ip6tables = 1
     net.ipv4.ip_forward = 1
     EOF

5. swap off

     swapoff -a
     sed -i '/ swap / s/^/#/' /etc/fstab
   
     sysctl --system

   3. 모든 Node에 대해 고유한 Hostname, Mac address, UUID 확인

   4. Cgroup Driver (택 1)

   Kubernetes Cluster에서 리눅스 컨트롤 그룹(cgroups)을 관리하는 방식에 대해 결정하는 역할 시스템 리소스(예: CPU, 메모리, 디스크 I/O 등)를 제한 및 각 프로세스나 서비스에 할당 방법을 감독하는 기능을 제공

6. 일관된 환경: Kubernetes 클러스터의 각 노드에서 systemd를 사용함으로써 부팅 스크립트, 서비스 관리 및 로깅 시스템 등에서 일관된 환경을 제공 -> 용이한 관리 및 트러블슈팅

7. 보다 나은 통합: systemd는 cgroups를 사용하여 리소스 제한과 프로세스 관리를 수행. Kubernetes는 이러한 기능을 활용하여 컨테이너의 리소스 사용을 제어 및 systemd와의 통합을 통해 강력하고 일관된 방식으로 관리 가능

8. 에러 최소화: 서로 다른 초기화 시스템이나 프로세스 관리자를 사용 시, 설정 차이나 호환성 문제로 인해 예기치 않은 에러가 발생할 수 있는데 systemd를 통일함으로써 호환성 문제를 최소화 가능

   
   

• systemd (k8s 공식 문서 권장, 필자가 사용한 Cgroup Driver )

  • 시스템 서비스와의 일관성: Kubernetes가 시스템의 다른 서비스와 동일한 cgroup 계층을 사용하게 되어 리소스 관리에서 충돌을 방지 및 전체 시스템의 리소스 할당을 일관되게 관리 가능

  • 보다 나은 자원 제어: cgroup을 더 체계적으로 관리하고, 시스템 리소스를 더 효율적으로 할당 및 모니터링할 수 있는 기능을 제공

  • 보안과 안정성: 보안 업데이트와 시스템 통합이 더 자주 이루어지므로, 보안과 안정성 측면에서 이점을 제공

• cgroupfs

  • 간단한 구성과 직접적인 제어

    각 cgroup을 파일 시스템으로 직접 제어할 수 있는 인터페이스를 제공하여 관리자가 리소스 관리를 직접적으로 수행할 수 있게 해주며, 복잡한 계층적 구조 없이도 세밀한 리소스 제어가 가능

    • 운영 체제와의 독립성 systemd를 사용하지 않는 리눅스 배포판에서도 일관된 환경을 제공하여 다양한 리눅스 환경에서의 포터빌리티(portability)를 향상시킴

    • 환경의 단순화 특정 시스템에 systemd의 복잡한 설정과 관리 로직이 필요 없을 경우, cgroupfs를 사용하면 시스템 단순화 및 시스템 오버헤드 감소로 더 가벼운 환경을 만드는 데 유리함

      5. CRI (택 1)

    • CRI-O ( 필자가 사용한 CRI )

      PROJECT_PATH=prerelease:/maincat <<EOF | tee /etc/yum.repos.d/cri-o.repo
      [cri-o]
      name=CRI-O
      baseurl=https://pkgs.k8s.io/addons:/cri-o:/$PROJECT_PATH/rpm/
      enabled=1
      gpgcheck=1
      gpgkey=https://pkgs.k8s.io/addons:/cri-o:/$PROJECT_PATH/rpm/repodata/repomd.xml.key
      EOF
      

    yum install -y container-selinux cri-o iproute-tc systemctl enable --now crio

    * containerd
    ### 6. k8s yum 저장소 추가 및 설치
    

  cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
  [kubernetes]
  name=Kubernetes
  baseurl=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/
  enabled=1
  gpgcheck=1
  repo_gpgcheck=1
  gpgkey=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/repodata/repomd.xml.key
  exclude=kube*
  EOF
  
  yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
  
  systemctl enable --now kubelet

  

Master

1. kubeadm init

    kubeadm init --apiserver-advertise-address=10.10.100.6 --pod-network-cidr=10.244.0.0/16

2. kubectl 권한주기

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

3. kubectl alias

    kubectl completion bash | tee /etc/bash_completion.d/kubectl > /dev/null
    echo 'alias k=kubectl' >>~/.bashrc
    echo 'complete -o default -F __start_kubectl k' >>~/.bashrc
    exec bash

Worker

1. kubeadm join

kubeadm init 하면서 얻은 토큰값으로 워커노드 전체에 kubeadm join

    kubeadm join 10.10.100.6:6443 --token jl7n01.taovls0ekgbmrlb8 \
            --discovery-token-ca-cert-hash sha256:171e155dd22b904e0827a8e262a54d777e9f4becf0aa24f066e2dcd3575e217c

2. crio.conf (insecure-registry)

도커 서버에서 insecure-registry 설정을 해줘도 k8s cluster와 이미지 관련 통신 때 cluster에서는 pod 생성 중 image pulling 과정에서 https 통신을 요청하기에 CRI에 insecure-registry 설정을 주어 k8s와 docker 사이의 통신을 맞춰준다. (https 통신을 원할경우 서로간의 ssl 인증설정이 추가적으로 필요)

    cat << EOF|tee /etc/containers/registries.conf.d/crio.conf
    unqualified-search-registries = ["docker.io", "quay.io"]

    [[registry]]
    prefix = ""
    location = "10.10.100.8:5000"
    insecure = true
    EOF

    systemctl restart crio

In Cluster

1. CNI 배포 ( 택 1 )

• calico

     kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

• flannel ( 필자가 사용한 CNI )

     kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

• etc ...

  2. Check Cluster

• k get nodes

• k get all --all-namespaces -o wide

3. 3-Tier Architecting ( Dev )

# 이미지는 내가 보여주고자 하는 내용을 담은 내가 만든 tomcat 9.0 이미지다.

• Dev.yaml

      apiVersion: v1
      kind: Namespace
      metadata:
        name: dev
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: dev-nginx-deployment
        namespace: dev
        labels:
          app: dev-nginx
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: dev-nginx
        template:
          metadata:
            labels:
              app: dev-nginx
          spec:
            containers:
            - name: dev-nginx
              image: nginx:latest
              ports:
              - containerPort: 80
              volumeMounts:
              - name: dev-nginx-conf-volume
                mountPath: /etc/nginx/nginx.conf
                subPath: nginx.conf
            volumes:
            - name: dev-nginx-conf-volume
              configMap:
                name: dev-nginx-config
      ---
      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: dev-nginx-config
        namespace: dev
      data:
        nginx.conf: |
          user  nginx;
          worker_processes  1;
          error_log  /var/log/nginx/error.log warn;
          pid        /var/run/nginx.pid;
          events {
              worker_connections  1024;
          }
          http {
              include       /etc/nginx/mime.types;
              default_type  application/octet-stream;
              log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                                '$status $body_bytes_sent "$http_referer" '
                                '"$http_user_agent" "$http_x_forwarded_for"';
              access_log  /var/log/nginx/access.log  main;
              sendfile        on;
              keepalive_timeout  65;
              server {
                  listen       80;
                  location / {
                      proxy_pass http://dev-tomcat-clusterip-service:8080;
                      proxy_set_header Host $host;
                      proxy_set_header X-Real-IP $remote_addr;
                      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                      proxy_set_header X-Forwarded-Proto $scheme;
                  }
              }
          }
  
      ---
  
      apiVersion: v1
      kind: Service
      metadata:
        name: dev-nginx-clusterip-service
        namespace: dev
      spec:
        selector:
          app: dev-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: dev-nginx-nodeport-service
        namespace: dev
      spec:
        type: NodePort
        selector:
          app: dev-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
            nodePort: 30007
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: dev-tomcat-deployment
        namespace: dev
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: dev-tomcat
        template:
          metadata:
            labels:
              app: dev-tomcat
          spec:
            containers:
            - name: dev-tomcat
              image: 10.10.100.8:5000/tomcat-custom:dev
              ports:
              - containerPort: 8080
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: dev-tomcat-clusterip-service
        namespace: dev
      spec:
        type: ClusterIP
        selector:
          app: dev-tomcat
        ports:
        - protocol: TCP
          port: 8080
          targetPort: 8080

  
  

• k get all -n dev -o wide

• sessionCheck.jsp

  ![](https://velog.velcdn.com/images/sanbon_8/post/f6d4e331-e22b-42f7-a6c7-7355e06a2843/image.png) ![](https://velog.velcdn.com/images/sanbon_8/post/351255e2-e13c-4399-86e3-f028f081c13b/image.png)

• checkDBConnection.jsp

4. [ Dev / Stg / Prd ] Separation

dev와 비슷한 구조로 namespace와 이미지를 다르게 해서 스테이징 환경 ( stg ), 프로덕션 환경 ( prd )을 배포해준다

• stg.yaml

      apiVersion: v1
      kind: Namespace
      metadata:
        name: stg
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: stg-nginx-deployment
        namespace: stg
        labels:
          app: stg-nginx
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: stg-nginx
        template:
          metadata:
            labels:
              app: stg-nginx
          spec:
            containers:
            - name: stg-nginx
              image: nginx:latest
              ports:
              - containerPort: 80
              volumeMounts:
              - name: stg-nginx-conf-volume
                mountPath: /etc/nginx/nginx.conf
                subPath: nginx.conf
            volumes:
            - name: stg-nginx-conf-volume
              configMap:
                name: stg-nginx-config
      ---        
      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: stg-nginx-config
        namespace: stg
      data:
        nginx.conf: |
          user  nginx;
          worker_processes  1;
          error_log  /var/log/nginx/error.log warn;
          pid        /var/run/nginx.pid;
          events {
              worker_connections  1024;
          }
          http {
              include       /etc/nginx/mime.types;
              default_type  application/octet-stream;
              log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                                '$status $body_bytes_sent "$http_referer" '
                                '"$http_user_agent" "$http_x_forwarded_for"';
              access_log  /var/log/nginx/access.log  main;
              sendfile        on;
              keepalive_timeout  65;
              server {
                  listen       80;
                  location / {
                      proxy_pass http://stg-tomcat-clusterip-service:8080;
                      proxy_set_header Host $host;
                      proxy_set_header X-Real-IP $remote_addr;
                      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                      proxy_set_header X-Forwarded-Proto $scheme;
                  }
              }
          }
  
      ---
  
      apiVersion: v1
      kind: Service
      metadata:
        name: stg-nginx-clusterip-service
        namespace: stg
      spec:
        selector:
          app: stg-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: stg-nginx-nodeport-service
        namespace: stg
      spec:
        type: NodePort
        selector:
          app: stg-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
            nodePort: 30008
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: stg-tomcat-deployment
        namespace: stg
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: stg-tomcat
        template:
          metadata:
            labels:
              app: stg-tomcat
          spec:
            containers:
            - name: stg-tomcat
              image: 10.10.100.8:5000/tomcat-custom:stg
              ports:
              - containerPort: 8080
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: stg-tomcat-clusterip-service
        namespace: stg
      spec:
        type: ClusterIP
        selector:
          app: stg-tomcat
        ports:
        - protocol: TCP
          port: 8080
          targetPort: 8080

  

• prd.yaml

      apiVersion: v1
      kind: Namespace
      metadata:
        name: prd
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: prd-nginx-deployment
        namespace: prd
        labels:
          app: prd-nginx
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: prd-nginx
        template:
          metadata:
            labels:
              app: prd-nginx
          spec:
            containers:
            - name: prd-nginx
              image: nginx:latest
              ports:
              - containerPort: 80
              volumeMounts:
              - name: prd-nginx-conf-volume
                mountPath: /etc/nginx/nginx.conf
                subPath: nginx.conf
            volumes:
            - name: prd-nginx-conf-volume
              configMap:
                name: prd-nginx-config
      ---
      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: prd-nginx-config
        namespace: prd
      data:
        nginx.conf: |
          user  nginx;
          worker_processes  1;
          error_log  /var/log/nginx/error.log warn;
          pid        /var/run/nginx.pid;
          events {
              worker_connections  1024;
          }
          http {
              include       /etc/nginx/mime.types;
              default_type  application/octet-stream;
              log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                                '$status $body_bytes_sent "$http_referer" '
                                '"$http_user_agent" "$http_x_forwarded_for"';
              access_log  /var/log/nginx/access.log  main;
              sendfile        on;
              keepalive_timeout  65;
              server {
                  listen       80;
                  location / {
                      proxy_pass http://prd-tomcat-clusterip-service:8080;
                      proxy_set_header Host $host;
                      proxy_set_header X-Real-IP $remote_addr;
                      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                      proxy_set_header X-Forwarded-Proto $scheme;
                  }
              }
          }
  
      ---
  
      apiVersion: v1
      kind: Service
      metadata:
        name: prd-nginx-clusterip-service
        namespace: prd
      spec:
        selector:
          app: prd-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: stg-nginx-nodeport-service
        namespace: stg
      spec:
        type: NodePort
        selector:
          app: stg-nginx
        ports:
          - protocol: TCP
            port: 80
            targetPort: 80
            nodePort: 30009
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: prd-tomcat-deployment
        namespace: prd
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: prd-tomcat
        template:
          metadata:
            labels:
              app: prd-tomcat
          spec:
            containers:
            - name: prd-tomcat
              image: 10.10.100.8:5000/tomcat-custom:prd
              ports:
              - containerPort: 8080
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: prd-tomcat-clusterip-service
        namespace: prd
      spec:
        type: ClusterIP
        selector:
          app: prd-tomcat
        ports:
        - protocol: TCP
          port: 8080
          targetPort: 8080

  

5. Ingress & Nginx Ingress Controller

• Nginx Ingress Controller 설치

       k apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.6.4/deploy/static/provider/cloud/deploy.yaml

  이후 Master Node의 IP를 할당해준다. !!! 공인 IP를 할당받은 VM이기에 가능하므로 로컬에서 연습할 시 metallb를 추가해 진행할 것

       k patch svc -n ingress-nginx ingress-nginx-controller -p '{"spec": {"type": "LoadBalancer", "externalIPs":["110.165.18.225"]}}'

  

  • 각 namespace에 ingress 배포

       apiVersion: networking.k8s.io/v1
       kind: Ingress
       metadata:
         name: ingress-nginx
         namespace: dev
         annotations:
           nginx.ingress.kubernetes.io/rewrite-target: /
           kubernetes.io/ingress.class: nginx
       spec:
         ingressClassName: "nginx"
         rules:
         - http:
             paths:
             - path: /dev
               pathType: Prefix
               backend:
                 service:
                   name: dev-nginx-clusterip-service
                   port:
                     number: 80
       ---
       apiVersion: networking.k8s.io/v1
       kind: Ingress
       metadata:
         name: ingress-nginx
         namespace: stg
         annotations:
           nginx.ingress.kubernetes.io/rewrite-target: /
           kubernetes.io/ingress.class: nginx
       spec:
         ingressClassName: "nginx"
         rules:
         - http:
             paths:
             - path: /stg
               pathType: Prefix
               backend:
                 service:
                   name: stg-nginx-clusterip-service
                   port:
                     number: 80
       ---
       apiVersion: networking.k8s.io/v1
       kind: Ingress
       metadata:
         name: ingress-nginx
         namespace: prd
         annotations:
           nginx.ingress.kubernetes.io/rewrite-target: /
           kubernetes.io/ingress.class: nginx
       spec:
         ingressClassName: "nginx"
         rules:
         - http:
             paths:
             - path: /prd
               pathType: Prefix
               backend:
                 service:
                   name: prd-nginx-clusterip-service
                   port:
                     number: 80

    

ETC

Cgroup Driver

리눅스 컨트롤 그룹(cgroups) 관리 방식 결정 컨테이너 리소스 제한 및 모니터링 기능 제공

systemd의 특징:

• 시스템 및 서비스 매니저로 초기화, 관리, 종료 담당
• 단위(unit) 파일로 서비스 관리
• 병렬 처리로 부팅 시간 최적화
• journal을 사용한 통합 로깅 시스템
• cgroups를 통한 프로세스 및 리소스 관리

cgroupfs의 특징:

• 리소스 제한 및 모니터링을 직접적으로 파일 시스템 인터페이스로 관리
• 계층적 그룹 관리로 각 그룹에 리소스 제한 적용 가능
• 프로세스 그룹화로 시스템 관리 효율성 증가
• 다양한 리소스 관리 컨트롤러 제공

systemd vs cgroupfs:

• 목적과 범위: systemd는 시스템 전체의 서비스 생명주기 및 리소스 관리에 초점. cgroupfs는 리소스 제한과 관리에 특화
• 통합과 독립성: systemd는 cgroup 관리를 시스템의 다른 부분과 통합하여 관리. cgroupfs는 독립적으로 리소스 제어 가능
• 인터페이스: systemd는 고수준의 서비스 관리 인터페이스 제공. cgroupfs는 저수준의 파일 시스템 인터페이스 사용

CRI (Container Runtime Interface)

컨테이너 런타임과 오케스트레이션 시스템 연결 표준 인터페이스 컨테이너 생성, 시작, 정지, 삭제 API 제공

CRI-O 특징:

• 쿠버네티스 전용 경량 런타임
• OCI 표준 준수
• 네트워크, 스토리지 플러그인 지원
• 컨테이너 격리 실행으로 보안 강화
• 구조 간소화

containerd 특징:

• 범용 컨테이너 런타임.
• OCI 이미지, 런타임 규격 지원
• 모듈형 설계
• 확장성 있는 플러그인 구조
• 강력한 커뮤니티 지원

CRI-O vs containerd 차이:

• 목표: CRI-O는 쿠버네티스 전용, containerd는 다양한 플랫폼 지원
• 플러그인: CRI-O는 쿠버네티스 최적화 플러그인, containerd는 범용 플러그인 구조
• 사용 환경: CRI-O는 주로 쿠버네티스, containerd는 쿠버네티스 및 기타 도구 사용

CNI (Container Network Interface)

Kubernetes의 컨테이너 간 네트워킹 설정을 위한 Plugin Interface 네트워크 연결과 IP 주소 할당 등을 관리

Calico의 특징:

• 고성능 데이터 플레인 제공
• 확장 가능한 네트워크 정책
• IPv4/IPv6 동시 지원

Cilium의 특징:

• eBPF 기반으로 고성능 보장
• 레이어 7 정책 실행 가능
• 네트워크 보안에 초점

Flannel의 특징:

• 간단한 설치 및 설정
• 오버레이 네트워킹을 통한 트래픽 라우팅
• VXLAN, UDP를 지원하는 네트워크 백엔드 제공

CNI들의 차이점:

• Calico는 보안과 성능에 초점을 맞춘 네트워크 정책 기능이 강점.
• Cilium은 최신 eBPF 기술을 활용해 보안과 성능을 강화한 CNI.
• Flannel은 설치와 관리의 용이성에 초점을 맞춘, 기본적인 오버레이 네트워크 솔루션을 제공

Ingress Controller

쿠버네티스에서 외부 요청을 내부 서비스로 연결 규칙 기반 라우팅 제공

NGINX Ingress Controller 특징:

• 리버스 프록시, 로드 밸런서로 사용되는 NGINX 사용
• 설정 유연성과 성능에서 강점
• 안정성 높고, 커스텀화 용이

ALB Ingress Controller 특징:

• AWS의 Application Load Balancer 사용
• 자동 스케일링 및 AWS 서비스와의 통합 용이
• 비용 효율적으로 다수의 HTTP, HTTPS 트래픽 처리

차이점:

• 구현 기반: NGINX는 오픈 소스 리버스 프록시, ALB는 AWS의 상업적 로드 밸런서
• 플랫폼 통합: NGINX는 다양한 환경에 배포 가능, ALB는 AWS 환경에 최적화
• 기능과 성능: NGINX는 커스텀 설정에 강점, ALB는 클라우드 특화 기능 및 자동화에 초점

flannel 설치 에러

error validating data: failed to download openapi: Get "https://10.10.100.6:6443/openapi/v2?timeout=32s": tls: failed to verify certificate: x509: certificate signed by unknown authority (possibly because of "crypto/rsa: verification error" while trying to verify candidate authority certificate "kubernetes"); if you choose to ignore these errors, turn validation off with --validate=false

보통 기존 kubeadm reset 이후 $HOME/.kube를 삭제하지 않아서 생기는 오류 막연하게 덮어쓰기 식으로 복붙 명령문 실행이 아닌

rm -rf $HOME/.kube

라는 명령어를 통해 삭제 후 진행해보자

1. Docker & Proxy, Maria DB, Redis Server 구축

전체 아키텍처 구상

[Docker Server] (10.10.100.6)

yum remove -y docker \
                    docker-client \
                    docker-client-latest \
                    docker-common \
                    docker-latest \
                    docker-latest-logrotate \
                    docker-logrotate \
                    docker-engine

yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

yum install -y docker-ce \
          docker-ce-cli \
          containerd.io \
          docker-buildx-plugin \
          docker-compose-plugin
systemctl enable --now docker

yum install -y nginx && systemctl enable --now nginx

# docker -> 컨테이너 서비스를 위해서 # nginx -> ncp alb 서비스와 연결할 프록시 설정을 위해서

[MariaDB Server] (10.10.100.7)

yum install mariadb mariadb-server && systemctl enable --now mariadb

# 이후 WAS 컨테이너와의 연동을 위한 user, database를 만들어주자 # mysql -u root -p MariaDB [(none)]>

grant all privileges on *.* to 'test'@'%' identified by '0000';
flush privileges;
create database test;

[Redis Server] (10.10.100.8)

yum install -y redis && systemctl enable --now redis

2. Docker Network Create & Image Pull

[Docker Server] *dpr -> docker private registry의 줄임말로 사용

docker network create \
        --driver bridge \
        --subnet 172.18.0.0/16 \
        --gateway 172.18.0.1 \
        web-bridge
docker network create \
        --driver bridge \
        --subnet 172.19.0.0/16 \
        --gateway 172.19.0.1 \
        was-bridge
docker network create \
        --driver bridge \
        --subnet 172.20.0.0/16 \
        --gateway 172.20.0.1 \
        dpr-bridge

docker network ls

docker pull nginx
docker pull tomcat:9.0
docker pull registry

docker images

3. Container Run

docker run --name web -d -p 81:80 --restart always --network web-bridge --network was-bridge nginx
docker run --name was -d -p 8081:8080 --restart always --network was-bridge tomcat:9.0
docker run --name in-lb -d -p 8080:80 --restart always --network was-bridge nginx 
docker run --name registry -d -p 5000:5000 --restart always --network dpr-bridge registry

docker ps

* 참고용 web -> 172.18.0.2 was -> 172.19.0.3 lb  -> 172.19.0.3 registry -> 172.20.0.2

4. Container Custom Setting

1) tomcat clustering & DB connect

[Docker Server] # docker exec -it was /bin/bash

root@<Container_ID>:/usr/local/tomcat#

cp -r ./webapps.dist/* ./webapps
exit

wget https://github.com/ran-jit/tomcat-cluster-redis-session-manager/releases/download/2.0.4/tomcat-cluster-redis-session-manager.zip
unzip tomcat-cluster-redis-session-manager.zip
docker cp ./tomcat-cluster-redis-session-manager/lib/. /usr/local/tomcat/lib/

redis.hosts=10.10.100.8:6379 ## redis endpoint 추가

docker cp ./tomcat-cluster-redis-session-manager/conf/. /usr/local/tomcat/conf/

<?xml version="1.0" encoding="UTF-8"?>

<Context>
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <WatchedResource>WEB-INF/tomcat-web.xml</WatchedResource>
    <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>
    <!-- 아래 내용 추가 -->
    <Valve className="tomcat.request.session.redis.SessionHandlerValve" />
    <Manager className="tomcat.request.session.redis.SessionManager" />
</Context>

docker cp context.xml was:/usr/local/tomcat/conf/context.xml

<%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
<%@ page import="java.text.*"%>
<%@ page import="java.util.*"%>
<%
        String RsessionId = request.getRequestedSessionId();
        String sessionId = session.getId();
        boolean isNew = session.isNew();
        long creationTime = session.getCreationTime();
        long lastAccessedTime = session.getLastAccessedTime();
        int maxInactiveInterval = session.getMaxInactiveInterval();
        Enumeration e = session.getAttributeNames();
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>Session Test</title>
</head>
<body>
<h1>WAS</h1>
<table border=1 bordercolor="gray" cellspacing=1 cellpadding=0
        width="100%">
        <tr bgcolor="gray">
                <td colspan=2 align="center"><font color="white"><b>Session
                Info</b></font></td>
        </tr>
        <tr>
                <td>Server HostName</td>
                <td><%=java.net.InetAddress.getLocalHost().getHostName()%></td>
        </tr>
        <tr>
                <td>Server IP</td>
                <td><%=java.net.InetAddress.getLocalHost()
                                                                        .getHostAddress()%></td>
        </tr>
        <tr>
                <td>Request SessionID</td>
                <td><%=RsessionId%></td>
        </tr>
        <tr>
                <td>SessionID</td>
                <td><%=sessionId%></td>
        </tr>
        <tr>
                <td>isNew</td>
                <td><%=isNew%></td>
        </tr>
        <tr>
                <td>Creation Time</td>
                <td><%=new Date(creationTime)%></td>
        </tr>
        <tr>
                <td>Last Accessed Time</td>
                <td><%=new Date(lastAccessedTime)%></td>
        </tr>
        <tr>
                <td>Max Inactive Interval (second)</td>
                <td><%=maxInactiveInterval%></td>
        </tr>
     <tr bgcolor="cyan">
                <td colspan=2 align="center"><b>Session Value List</b></td>
        </tr>
        <tr>
                <td align="center">NAME</td>
                <td align="center">VAULE</td>
        </tr>
        <%
                String name = null;
                while (e.hasMoreElements()) {
                        name = (String) e.nextElement();
        %>
        <tr>
                <td align="left"><%=name%></td>
                <td align="left"><%=session.getAttribute(name)%></td>
        </tr>
        <%
                }
        %>

</table>

        <%
                int count = 0;

                if(session.getAttribute("count") != null)
                        count = (Integer) session.getAttribute("count");

                count += 1;

                session.setAttribute("count", count);

                out.println(session.getId() + "     :     " + count);
        %>
</body>
</html>

[root@ldk-docker ~]#

docker cp sessionCheck.jsp was:/usr/local/tomcat/webapps/ROOT/sessionCheck.jsp
docker restart was

wget https://dlm.mariadb.com/3752064/Connectors/java/connector-java-2.7.12/mariadb-java-client-2.7.12.jar
docker cp mariadb-java-client-2.7.12.jar was:/usr/local/tomcat/lib/

<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.Connection"%>
<%@ page import="java.text.*"%>
<%@ page import="java.util.*"%>

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MariaDB 연결 드라이버 테스트</title>
</head>
<body>
        <h1>WAS</h1>
        <h2>Server IP: <%=java.net.InetAddress.getLocalHost().getHostAddress()%></h2>
        <h1>MariaDB 연결 드라이버 테스트</h1>
        <%
                String jdbcUrl = "jdbc:mariadb://10.10.100.7:3306/test";
                String dbId = "test";
                String dbPwd = "0000";

                try
                {
                        Class.forName("org.mariadb.jdbc.Driver");
                        Connection connection = DriverManager.getConnection(jdbcUrl, dbId, dbPwd);
                        out.println("MariaDB 연결 성공");
                }
                catch (Exception ex)
                {
                        out.println("연결 오류입니다. 오류 메시지 : " + ex.getMessage());
                }
        %>
</body>
</html>

docker cp checkDBConnection.jsp was:/usr/local/tomcat/webapps/ROOT/
docker restart was

2) Internal-LB Connect

# vim nginx.conf

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    #include /etc/nginx/conf.d/*.conf;
    upstream tomcat {
        server 172.19.0.3:8080;
    }
    server {
        listen 80;
        server_name localhost;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
            proxy_pass http://tomcat;
        }
    }
}

[root@ldk-docker ~]#

docker cp nginx.conf in-lb:/etc/nginx/nginx.conf
docker restart in-lb

# internal-lb 포트로 접속 시 tomcat 페이지가 나오는 것을 확인할 수 있다.

3) Web Connect

# vim nginx.conf

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    #include /etc/nginx/conf.d/*.conf;
    upstream inLB {
        server 172.19.0.4:80;
    }
    server {
        listen 80;
        server_name localhost;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
            proxy_pass http://inLB;
        }
    }
}

[root@ldk-docker ~]#

docker cp nginx.conf web:/etc/nginx/nginx.conf
docker restart web

#WEB 포트로 접속시 tomcat page가 나오는 것을 확인할 수 있다

4) Server Proxy Connect

# vim /etc/nginx/nginx.conf

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    #include /etc/nginx/conf.d/*.conf;
    upstream web {
        server 172.18.0.2:80;
    }
    server {
        listen 80;
        server_name localhost;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
            proxy_pass http://web;
        }
    }
}

[root@ldk-docker ~]#

systemctl restart nginx

# default port로 접속시 tomcat page가 나오는 것을 확인 할 수 있다

5. Docker Image Push (Docker Private Registry)

[root@ldk-docker ~]#

docker commit web localhost:5000/custom-web:1.0
docker commit was localhost:5000/custom-was:1.0
docker commit in-lb localhost:5000/custom-lb:1.0

docker push localhost:5000/custom-web:1.0
docker push localhost:5000/custom-was:1.0
docker push localhost:5000/custom-lb:1.0

docker rmi localhost:5000/custom-web:1.0
docker rmi localhost:5000/custom-was:1.0
docker rmi localhost:5000/custom-lb:1.0

docker run --name web2 -d -p 82:80 --restart always --network web-bridge --network was-bridge localhost:5000/custom-web:1.0
docker run --name was2 -d -p 8082:8080 --restart always --network was-bridge localhost:5000/custom-was:1.0

6. Docker-Compose

# Docker compose를 통해 컨테이너를 통합 생성 및 제거가 가능하다 # 이미지 생성 이후 web과 internal LB의 nginx.conf의 수정사항이 있었으므로 이미지 업데이트를 해준다

[root@ldk-docker ~]#

docker commit web2 localhost:5000/custom-web:1.1
docker commit in-lb localhost:5000/custom-lb:1.1

docker push localhost:5000/custom-web:1.1
docker push localhost:5000/custom-lb:1.1

docker rmi localhost:5000/custom-web:1.1
docker rmi localhost:5000/custom-lb:1.1

services:
  web01:
    image: localhost:5000/custom-web:1.1
    restart: always
    networks:
      - web-bridge
      - was-bridge
    container_name: web01
    expose:
      - 80
    depends_on:
      - internal-LB
  web02:
    image: localhost:5000/custom-web:1.1
    restart: always
    networks:
      - web-bridge
      - was-bridge
    container_name: web02
    expose:
      - 80
    depends_on:
      - web01
  internal-LB:
    image: localhost:5000/custom-lb:1.1
    restart: always
    networks:
      - was-bridge
    container_name: in-lb
    expose:
      - 80
    depends_on:
      - was02
  was01:
    image: localhost:5000/custom-was:1.0
    restart: always
    networks:
      - was-bridge
    container_name: was01
    expose:
      - 8080
  was02:
    image: localhost:5000/custom-was:1.0
    restart: always
    networks:
      - was-bridge
    container_name: was02
    expose:
      - 8080
    depends_on:
      - was01
networks:
  web-bridge:
    external: true
  was-bridge:
    external: true
  dpr-bridge:
    external: true

docker compose up -d
docker ps

# ( IMAGE 태그는 실습과정에서 생긴 차이이므로 무시하자 )

# Load Balancer 테스트

[root@ldk-docker ~]#

docker compose down
docker ps -a

# 컨테이너가 사라진 것을 확인 할 수 있다

[WAS 1, 2] # DB를 연결하기 위해서 mariadb-connector가 필요하므로 해당 파일을 받아주자 # 필자의 톰캣 설치 디렉토리 위치는 /usr/local/ 이므로 상황에 맞게 경로 설정을 바꿔주자

cd /usr/local/tomcat/lib wget https://dlm.mariadb.com/3752064/Connectors/java/connector-java-2.7.12/mariadb-java-client-2.7.12.jar

cd /usr/local/tomcat/webapps/ROOT vim checkDBConnect.jsp

<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.Connection"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MariaDB 연결 드라이버 테스트</title>
</head>
<body>
        <h1>WAS1 또는 WAS2</h1>
        <h1>MariaDB 연결 드라이버 테스트</h1>
        <%
                String jdbcUrl = "jdbc:mariadb://<MAXSCALE_IP>:3306/pj";
                String dbId = "slave";
                String dbPwd = "0000";

                try
                {
                        Class.forName("org.mariadb.jdbc.Driver");
                        Connection connection = DriverManager.getConnection(jdbcUrl, dbId, dbPwd);
                        out.println("MariaDB 연결 성공");
                }
                catch (Exception ex)
                {
                        out.println("연결 오류입니다. 오류 메시지 : " + ex.getMessage());
                }
        %>
</body>
</html>

일종의 DB Proxy 역할로 Read / Write 분리, VIP 접근 / Auto Failover 기능을 설정할 수 있다. # Maxscale은 WAS 서버와 DB 서버 사이에 위치해야하며 새로 추가적인 인스턴스를 생성해주자

[maxscale] # maxscale 자체는 yum 기능에서 찾지 못하므로 repo 설정 후 찾아야한다. curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | bash yum install -y maxscale

systemctl enable --now maxscale

vim /etc/maxscale.cnf

[server1]
type=server
address=<MASTER_DB_IP>
port=3306
protocol=MariaDBBackend

[server2]
type=server
address=<SLAVE_DB_IP>
port=3306
protocol=MariaDBBackend


[Maria-Monitor]
type=monitor
module=mariadbmon
servers=server1, server2
user='slave'
password='0000'
monitor_interval=2000ms
auto_failover=true
auto_rejoin=true


[Splitter-Service]
type=service
router=readwritesplit
servers=server1,server2
user='slave'
password='0000'

[Splitter-Listener]
type=listener
service=Splitter-Service
protocol=MariaDBClient
port=3306

systemctl restart maxscale

mysql -u slave -p'0000' -h <MAXSCALE_IP> -e "use pj; insert into user(name,password) values (@@hostname, @@hostname);"

[masterDB] mysql -u root -p

MariaDB[(none)]>

use pj; select * from user;

# WRITE(insert)가 masterDB에서 작동한 것을 확인 할 수 있다

[maxscale] mysql -u slave -p'0000' -h <MAXSCALE_IP> -e "select @@hostname;" # READ(select)가 slaveDB에서 작동한 것을 확인 할 수 있다

maxctrl list servers;

# masterDB -> systemctl stop mariadb 후 slaveDB가 Master로 승격한 것을 볼 수 있다.

[slaveDB] mysql -u root -p

mariaDB[(none)]>

use pj; insert into user(name,password) values('XXX','XXX');

mariaDB[(none)]>

use pj; select * from user;

# auto_failover로 인해 masterDB에도 저장되는 것을 확인할 수 있다

# 단 master / slave 구조가 역으로 구성된다.

[maxscale] maxctrl call command mariadbmon switchover MariaDB-Monitor server1 server2 maxctrl list servers # switchover 명령문으로 다시 M / S 구조가 원상태로 돌아간 것을 확인할 수 있다.

[Master & Slave DB] yum install -y mariadb mariadb-server systemctl enable --now mariadb

[Master DB]

vim /etc/my.cnf

[mysqld]
log-bin = mysql-bin
server-id = 1

systemctl restart mariadb mysql -u root -p

MariaDB [(none)]>

grant all privileges on *.* to 'slave'@'%' identified by '0000';
flush privileges;
show master status;
select binlog_gtid_pos(MASTER_LOG_FILE, MASTER_LOG_POS);

# File명과 Position 번호 필요

[Slave DB]

vim /etc/my.cnf

[mysqld]
log-bin = mysql-bin
server-id = 2

systemctl restart mariadb mysql -u root -p

MariaDB [(none)]>

stop slave;

change master to
  master_host='masterDB_IP', # master서버 ip 주소
  master_user='slave', #master mysql 계정
  master_password='0000', # master mysql 계정 비밀번호
  master_use_gtid=slave_pos;

start slave;
show slave status\G;

# Slave_IO_Running, Slave_SQL_Running 둘다 Yes 들어오면 연결 성공

MariaDB [(none)]>

create database pj;
use pj;
create table user(
    id int(10) auto_increment primary key,
    name varchar(20) not null,
    password varchar(20) not null);
insert into user(name,password) values('AAA','AAA');

[Slave DB] mysql -u root -p

MariaDB[(none)]>

use pj; select * from user;

# slave에 비동기 저장된 것을 확인 할 수 있다.

[WAS 1] vim /usr/local/tomcat/conf/server.xml

# Engine name 블럭을 찾아 집어 넣는다

<!-- clustering -->
        <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster" channelSendOptions="8"  channelStartOptions="3">
                <Manager className="org.apache.catalina.ha.session.DeltaManager" expireSessionsOnShutdown="false" notifyListenersOnReplication="true"/>
                <Channel className="org.apache.catalina.tribes.group.GroupChannel">
                        <Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">
                                <Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender" />
                        </Sender>
                        <Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"
                        address="WAS1_IP"
                        port="4055"
                        autoBind="0"
                        selectorTimeout="5000"
                        maxThreads="6"/>

                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpPingInterceptor" staticOnly="true"/>
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector" />
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.StaticMembershipInterceptor">
                        <Member
                                className="org.apache.catalina.tribes.membership.StaticMember"
                                port="4056"
                                host="WAS2_IP"
                                uniqueId="{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2}"
                        />
                        </Interceptor>
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatchInterceptor"/>
                </Channel>

                <Valve className="org.apache.catalina.ha.tcp.ReplicationValve" filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;" />
                <Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>
                <ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener" />
        </Cluster>
        <!-- clustering  -->

[WAS 2] vim /usr/local/tomcat/conf/server.xml

# Engine name 블럭을 찾아 집어 넣는다

<!-- clustering -->
        <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster" channelSendOptions="8"  channelStartOptions="3">
                <Manager className="org.apache.catalina.ha.session.DeltaManager" expireSessionsOnShutdown="false" notifyListenersOnReplication="true"/>
                <Channel className="org.apache.catalina.tribes.group.GroupChannel">
                        <Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">
                                <Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender" />
                        </Sender>
                        <Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"
                        address="WAS2_IP"
                        port="4055"
                        autoBind="0"
                        selectorTimeout="5000"
                        maxThreads="6"/>

                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpPingInterceptor" staticOnly="true"/>
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector" />
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.StaticMembershipInterceptor">
                        <Member
                                className="org.apache.catalina.tribes.membership.StaticMember"
                                port="4056"
                                host="WAS1_IP"
                                uniqueId="{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}"
                        />
                        </Interceptor>
                        <Interceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatchInterceptor"/>
                </Channel>

                <Valve className="org.apache.catalina.ha.tcp.ReplicationValve" filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;" />
                <Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>
                <ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener" />
        </Cluster>
        <!-- clustering  -->

[WAS 1,2] cd /usr/local/tomcat/webapps/ROOT/WEB-INF vim web.xml

#추가
<distributable/>

[Web 1,2] yum install -y httpd systemctl enable --now httpd vi /etc/httpd/conf/httpd.conf

ServerName <WEB-Public-IP>

[Was 1,2] # NaverCloudServer는 기본적으로 java 8(1.8)버전 -> 호환하는 Tomcat 버전은 10.0.X까지 # 안정적인 Tomcat 9로 사용해보겠다

cd /usr/local wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.86/bin/apache-tomcat-9.0.86.tar.gz tar -xzvf apache-tomcat-9.0.86.tar.gz mv apache-tomcat-9.0.86 tomcat vim /usr/lib/systemd/system/tomcat.service

[Unit]
Description=tomcat
After=network.target syslog.target

[Service]
Type=forking

User=root
Group=root

ExecStart=/usr/local/tomcat/bin/startup.sh
ExecStop=/usr/local/tomcat/bin/shutdown.sh

UMask=0007
RestartSec=10
Restart=always

SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

# source ~/.bash_profile systemctl enable --now tomcat

1. Mod_JK를 사용할 시

[Web 1,2] yum install -y autoconf libtool gcc gcc-c++ httpd-devel wget https://dlcdn.apache.org/tomcat/tomcat-connectors/jk/tomcat-connectors-1.2.49-src.tar.gz tar -xvzf tomcat-connectors-1.2.49-src.tar.gz mv tomcat-connectors-1.2.49-src tomcat-connectors cd tomcat-connectors/native ./buildconf.sh ./configure --with-apxs=/bin/apxs make && make install

LoadModule jk_module modules/mod_jk.so

<VirtualHost *:80>
ServerName <web-ip>
DocumentRoot "/var/www/html"
ErrorLog "logs/localhost-error_log"
CustomLog "logs/localhost-access_log" common
JKUnMount /*.html tomcat
JkMount    / tomcat
</VirtualHost>

Include /etc/httpd/conf.modules.d/mod_jk.conf

<IfModule jk_module>
JkWorkersFile conf/workers.properties
JkLogFile logs/mod_jk.log
JkshmFile logs/mod_jk.shm
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
</IfModule>

worker.list=tomcat

worker.tomcat.port=8009
worker.tomcat.host=<in-nlb-ip>
worker.tomcat.type=ajp13
worker.tomcat.lbfactor=1

# 아래 내용의 주석 내용을 삭제
# 해당 블록을 찾아 'URIEncoding="UTF-8"'를 넣어주자
<Connector protocol="AJP/1.3"
           address="0.0.0.0"
           port="8009"
           redirectPort="8443" 
           maxParameterCount="1000"
           secretRequired="false"
           />

systemctl restart tomcat

2. Mod_Proxy를 사용할 시

Mod_proxy로 하려면! (NLB 말고 ALB 가능하다!!) vim /etc/httpd/conf/httpd.conf

<VirtualHost *:80>
    ProxyRequests Off
    ProxyPreserveHost On
    <Proxy *>
        Order deny,allow
        Allow from all
    </Proxy>
    ProxyPass / http://10.10.2.6:8080/ disablereuse=on
    ProxyPassReverse / http://10.10.2.6:8080/
</VirtualHost>

# ServerName도 주석제거하고 자기 IP 번호로 변경

# 아래 내용의 주석 내용을 삭제
# 해당 블록을 찾아 'URIEncoding="UTF-8"'를 넣어주자
<Connector port="8080" protocol="HTTP/1.1"
               URIEncoding="UTF-8" 
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />

systemctl restart tomcat

1.1 인프라 구축

1.1.1 VPC

네트워크 만들기

이름: tokyo-vpc 서브넷: 커스텀

subnet01

이름: tokyo-subnet01 리전: asia-northeast1 IPv4 범위: 10.127.0.0/22 완료

이름: tokyo-subnet02 리전: asia-northeast1 IPv4 범위: 10.127.4.0/22 완료

방화벽 규칙 전부 체크 만들기

결과

1.1.2 인스턴스

인스턴스 만들기

1.1.2.1 gcp-tokyo-web01

이름: gcp-tokyo-web01 리전: asia-northeast1 (도쿄) 영역: asia-northeast1-a 머신 유형: e2-micro

부팅 디스크 -> 변경 공개 이미지 운영체제: CentOS 버전: CentOS 7 크기: 20GB 선택

네트워크 인터페이스 네트워크 인터페이스 수정 네트워크: tokyo-vpc 서브 네트워크: tokyo-subnet01 외부 IPv4 주소: 없음 완료

시작 스크립트

#!/bin/bash
yum install -y httpd
systemctl enable --now httpd
echo "<h1>tokyo-web01</h1>" > /var/www/html/index.html

1.1.2.2 gcp-tokyo-web01

이름: gcp-tokyo-web02 리전: asia-northeast1 (도쿄) 영역: asia-northeast1-c 머신 유형: e2-micro

부팅 디스크 -> 변경 공개 이미지 운영체제: CentOS 버전: CentOS 7 크기: 20GB 선택

네트워크 인터페이스 네트워크 인터페이스 수정 네트워크: tokyo-vpc 서브 네트워크: tokyo-subnet02 외부 IPv4 주소: 없음 완료

시작 스크립트

#!/bin/bash
yum install -y httpd
systemctl enable --now httpd
echo "<h1>tokyo-web02</h1>" > /var/www/html/index.html

1.2 AWS GCP VPN 연결

1.2.1 GCP 고정 IP 주소 할당

이름: gcp-vp 리전: asia-northeast1 예약

할당 받은 IP: 35.187.203.206

1.2.2 AWS 고객 게이트웨이 생성

이름: aws-gcp-cgw IP 주소: gcp-vp ip (35.187.203.206)

1.2.3 AWS 가상 프라이빗 게이트웨이 확인

기존에 OpenStack VPN 연결에 사용했던 프라이빗 게이트웨이 사용(center04-vgw)

1.2.4 AWS VPN 연결 생성

공급업체: Generic 다운로드

vpn-04e4b1510414f79e3.txt

IKE version: IKEv2

IPSec Tunnel #1

Pre-Shared Key: AwrRicXOs8YiHKtKYr7oBtUT2BkfRxcS Outside IP Addresses-Virtual Private Gateway: 43.200.210.83

IPSec Tunnel #2

Pre-Shared Key: pJLBhDTHrj959Oge7UAuE4tnQzK5bJ88 Outside IP Addresses-Virtual Private Gateway: 52.78.67.73

1.2.5 GCP VPN Gateway 생성

이름: gcp-aws-vgw 네트워크: tokyo-vpc 리전: asia-northeast1(도쿄) IP 주소: gcp-vp ip (35.187.203.206)

이름: vpn-1-tunnel-1 원격 피어 IP 주소: 43.200.210.83 IKE 버전: IKEv2 IKE 사전 공유 키: AwrRicXOs8YiHKtKYr7oBtUT2BkfRxcS 라우팅 옵션: 라우팅 기반 원격 네트워크 IP 범위: AWS VPC 범위 (10.35.0.0/16) 완료

이름: vpn-1-tunnel-2 원격 피어 IP 주소: 52.78.67.73 IKE 버전: IKEv2 IKE 사전 공유 키: pJLBhDTHrj959Oge7UAuE4tnQzK5bJ88 라우팅 옵션: 라우팅 기반 원격 네트워크 IP 범위: AWS VPC 범위 (10.35.0.0/16) 완료

생성 결과

1.2.6 AWS 라우팅 테이블 라우팅 편집

destination: 10.127.0.0/22 target: vpn gatway

destination: 10.127.0.0/22 target: vpn gatway

라우팅 추가

1.2.7 보안 그룹 인바운드 규칙 편집

gcp-vpc 가용영역 ICMP 규칙 허용

1.2.8 GCP VPC 방화벽 규칙 확인

2. CloudWatch

2.1 OpneStack 서버 및 GCP 인스턴스 CWAgent 설치

sudo su

yum install –y wget unzip

wget https://s3.amazonaws.com/amazoncloudwatch-agent/centos/amd64/latest/amazon-cloudwatch-agent.rpm
sudo rpm -U ./amazon-cloudwatch-agent.rpm

mkdir ~/.aws
vi ~/.aws/credentials
[AmazonCloudWatchAgent] 
aws_access_key_id = [Access_Key]
aws_secret_access_key = [Secret_Access_Key]
region = ap-northeast-2

vi /opt/aws/amazon-cloudwatch-agent/etc/common-config.toml
[credentials]
   shared_credential_profile = "AmazonCloudWatchAgent"
   shared_credential_file = "/root/.aws/credentials"

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

/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-config-wizard
#설정 시작
#linux -> On-Premises -> 쭉 디폴트로 진행 
#-> Log file path 에 '/home/centos/logs/**.log' 입력
#더이상 추가할 파일 없고 SSM 파라미터 스토어에 저장하지 않는다로 마무리

#생성한 설정 파일 확인하려면
vi /opt/aws/amazon-cloudwatch-agent/bin/config.json

mkdir -p /usr/share/collectd/ && touch /usr/share/collectd/types.db

systemctl enable —now amazon-cloudwatch-agent

#실행 명령어
/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m onPremise -s -c file:/opt/aws/amazon-cloudwatch-agent/bin/config.json

※ 처음은 system상 amazon-cloudwatch-agent.service가 실행되고 있지 않기 때문에 'stopped' 상태가 됐을시에 한번 더 실행시켜준다.

#중지 명령어
/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a stop

#CloudWatchAgent 로그 경로
/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log

2.2 sns 주제 및 구독 생성

2.3 경보 생성

경보 이름: gcp-web01-cpu-util-alarm 다음

경보 생성

Virtual Private Cloud 사용자의 AWS 계정 전용 가상 네트워크

1. 보안 그룹 설정

vpc 생성 전 전용 가상 네트워크 인바운드 규칙을 설정하여 사용할 수 있도록 한다.

2. VPC 생성

3. 서브넷 생성

• 결과

  

3. 인터넷 게이트웨이 생성

4. 생성한 게이트웨이를 VPC에 연결

5. 라우팅 테이블 생성

0.0.0.0/0 설정을 통해 어디서든지 어떤 IP던 간에 사용할 수 있도록 설정

1. 이미지 생성 (AMI)

2. AMI로 인스턴스 시작하기

3. 시작 템플릿 만들기 (auto scaling 기초)

4. 시작 템플릿으로 인스턴스 시작하기

S3 생성

1. EFS 생성

2. EFS 보안그룹 설정 (nfs)

1) 보안그룹 efs를 위한 nfs 규칙 만들기

2) 가용 영역 보안그룹 Default -> efs(내가 만든 보안 그룹)

3. EC2와 연결 확인

1) 연결 할 EC2 서버 접속

mkdir efs
sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport fs-0f43337d9fff133ab.efs.ap-northeast-2.amazonaws.com:/ efs

sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport fs-0f43337d9fff133ab.efs.ap-northeast-2.amazonaws.com:/ efs

해당 명령어는 빨간 네모칸에 있는 코드를 복사한 것이다

데이터 스토리지를 서비스로서 관리하고 운영하는 클라우드 컴퓨팅 공급자를 통해 데이터를 인터넷에 저장하는 클라우드 컴퓨팅 모델

1. EBS

EBS: Elastice Storage Service

1) 볼륨 생성

2) 볼륨 연결

3) 스냅샷 생성

4) 스냅샷을 통한 볼륨 생성 및 연결

가용 영역 변경해서 EC2-web02 서버 볼륨으로 사용

5) 스냅샷 복사를 통한 지역 변경 및 볼륨 생성

EC2: Amazon Elastic Compute Cloud 사용자가 가상 컴퓨터를 임대 받아 그 위에 자신만의 컴퓨터 애플리케이션들을 실행할 수 있게 하는 서비스

1. EC2 관련 페이지 접속

2. EC2 - 보안그룹

3. EC2 - 인스턴스 유형

t2.nano t2.micro : Free Tier

4. EC2 - 인스턴스 통합 제어 기능

5. EC2 - 인스턴스 시작

1) Name and tags

이름 : web01 (작성자가 사용하기 용이한 이름으로 설정)

2) 애플리케이션 및 OS 이미지

OS : Amazon Linux AMI : Amazon Linux 2 AMI (HVM) - Kernel 5.10, SSD Volume Type 아키텍처 : 64비트(x86)

인스턴스 유형 : t2.micro

이후 키 페어생성

3) 키 페어

키페어 이름 : new-key (자신이 쓰기 용이한 이름으로 짓기) 키 페어 유형 : RSA 프라이빗 키 파일 형식 : .pem

이후 키 페어 생성 클릭

다운로드 성공

4) 네트워크 설정

방화벽 (보안 그룹) : 파란 네모칸 전부 체크 이후 편집 버튼 클릭

(1) 서브넷

서브넷 : 서브넷 설정 보안 그룹 이름 : web (사용자가 사용하기 용이한 이름으로 설정)

(2) 보안 그룹 규칙

• 보안 그룹 규칙 1

  • 유형 : ssh
  • 소스 유형 : 내 IP

• 보안 그룹 규칙 2

  • 유형 : http
  • 소스 유형 : 위치 무관 (로드 밸런서를 위해서. 추후참고)

• 보안 그룹 규칙 3

  • 유형 : https
  • 소스 유형 : 위치 무관

• 보안 그룹 규칙 4

  • 유형 : 사용자 지정 TCP
  • 소스 유형 : 위치 무관 (로드 밸런서를 위해서. 추후참고)
  • 포트 범위 : 8080
  • 설명 : tomcat

• 보안 그룹 규칙 5

  • 유형 : 사용자 지정 ICMP - IPv4
  • 소스 유형 : 내 IP

5) 스토리지 구성

어드밴스드 클릭

gp3 -> gp2

종료 시 삭제 : 예

6) 고급 세부 정보

사용자 데이터

CentOS RedHat :

#!/bin/bash
yum install -y httpd
systemctl enable --now httpd
echo "<h1>web01</h1>" > /var/www/html/index.html

Ubuntu :

apt update
apt install -y apache2
echo "<h1>web02</h1>" > /var/www/html/index.html

7) 생성

(8) 결과

6. 탄력적 IP 주소

7. 로드밸런서

1) 과정

2) 결과

상태 : InService일 경우 잘 작동되고 있는 것이다.

8. 삭제

1) 인스턴스

2) 로드밸런서

3) 탄력적 IP 주소

해당 기능은 연결을 하지 않고 가지고 있을 시 비용이 나가므로 반드시 삭제해 주자

보안 자격 증명 (MFA)

MFA : Multi Factor Authentication

1. 보안 자격 증명 페이지 들어가기

우측 상단 이메일 -> 보안 자격 증명

2. MFA 할당 인증받기

MFA 할당

3. MFA 디바이스 선택

디바이스 이름: new-mfa ( 자신이 기억하기 용이한 이름으로 설정 ) MFA 디바이스 선택: 인증 관리자 앱

4. MFA 디바이스 설정

안드로이드 : otp (google otp) 아이폰 : google authenticator

1. QR 코드 표시
2. 앱을 통한 QR코드 인증 절차 밟기
3. MFA 코드 1 입력
4. 이후 바뀐 연속된 코드 2 입력
5. MFA 추가 클릭

5. MFA 할당 정보 확인

6. MFA 사용해보기

로그아웃 후 휴대폰 앱에 나오는 MFA 코드 입력 후 재로그인

1. 가입하기

https://aws.amazon.com/ko/free

계정 생성간 필요사항

1. 이메일
2. 휴대폰 인증
3. 집 주소
4. 해외결제 가능한 카드

Complete

2. 계정 설정

언어: 한국어 기본 리전(지역): 아시아 태평양(서울) ap-northeast-2