Minikube 와 함께하는 Kubernetes Study 4

Recommanded Free YOUTUBE Lecture: <% selectedImage[1] %>

yundream
2023-04-09
2023-03-01
2576

[Minikube 와 함께하는 Kubernetes 목차](https://www.joinc.co.kr/w/kubernetes_minikube_index)

지난번에는 [Minikube 와 함께하는 Kubernetes Study 3 - Service ](https://www.joinc.co.kr/w/kubernetes_service) 에서는 Kubernetes의 Service에 대해서 자세히 살펴봤다. Kubernetes 관리자는 Service를 이용해서 Deployment(혹은 POD)를 외부에 노출 할 수 있게 됐다. 이번에는 kubernetes Ingress를 다룰 건데, Ingress를 이용하면 노출된 서비스들을 HTTP/HTTPS 기반으로 더욱더 정교하게 라우팅 할 수 있다.

요약하면 Kubernetes Service는 POD를 내부적으로 노출하고 Kubernetes Ingress는 서비스를 보다 발전되고 유연한 형태로 외부세계(주로 인터넷)에 노출하는 역할을 한다.

# Kubernetes ingress
![kubernetes ingress](https://docs.google.com/drawings/d/e/2PACX-1vR1nYEAVohfRH1me3qTVUDQLyJvmDsIxQsXKeGCsPpJUKBtkQDHKyKixtbuHBWzc60blPINnwWY3FaV/pub?w=863&h=608)

**Kubernetes Ingress**는 클러스터 외부에서 클러스터 내의 서비스로 HTTP 및 HTTPS 요청을 전달할 수 있도록 하는 L7 로드밸런서 인터페이스를 제공한다. 인터페이스라고 하는 이유는 Ingress는 그 자체가 로드밸런서는 아니고, 로드밸런서를 탑재할 수 있는 인터페이스만 제공하기 때문이다. 예를들어 Kubernetes 관리자는 NginX, Traefik, Kong, AWS ELB와 같은 로드밸런서를 Ingress로 사용 할 수 있다.

### Kubernetes Ingress가 하는 일
Kubernetes Ingress는 오픈 혹슨 상용의 로드밸런서를 탑재할 수 있는 인터페이스를 제공하기 때문에 결국 L7 로드밸런서가 하는 일을 수행하게 된다.
1. 클라이언트의 요청을 받아서 URL, HOST 이름 또는 기타 메타데이터를 기반으로 다른 서비스로 라우팅한다. 예를들어 */music* 로 시작하는 URL은 music 서비스로, */photo* 로 시작하는 URL photo 서비스로 라우팅 할 수 있다. HOST 이름의 경우 HTTP 헤더의 HOST 필드의 값이 *HOST: user.example.com* 이라면 user 서비스로 *HOST: payment.example.com* 이라면 payment 서비스로 라우팅 할 수 있다.
2. 트래픽에 대한 SSL 인증서를 처리한다.
3. 들어오는 트래픽에 대한 부하 분산을 제공한다.
4. 속도 제한(rate limiting), 사용자 인증과 같은 다양한 기능들을 제공한다.

### Kubernetes Ingress Controller
Ingress는 L7 로드밸런서를 탑재하기 위한 인터페이스를 제공한다. 다양한 소프트웨어 로드밸런서, 하드웨어 로드밸런서를 탑재할 수 있는데 이를 위해서는 각 로드밸런서 마다 Ingress Controller의 구현이 필요하다. Kubernetes가 (거의)산업표준이 되면서 대부분의 주요 로드밸런서들은 Ingress Controller를 제공한다. 아래는 Ingress Controller를 제공하는 주요 로드밸런서들이다.
* HAProxy Ingress controller
* AKS Application Gateway Ingress controller
* Istio Ingress controller
* Kong Ingress controller
* NginX Ingress Controller
* Traefik Ingress Controller

## Ingress Type Application 개발
먼저 minikube cluster을 시작하자
```shell
$ minikube start
```
### 소프트웨어 아키텍처
그럼 Ingress Type의 서비스를 직접 구축해보도록 하자. 이 서비스는 아래와 같은 아키텍처를 가진다.

이 서비스는 music service와 photo service의 마이크로 서비스로 구성된 MSA 방식으로 전개한다. 이들 MSA 서비스는 Nginx Ingress controll로 묶을려고 한다.

따라서 이 NginX ingress controller는 아래와 같은 라우팅 룰을 가질 것이다. 
1. /music 는 music service 로 라우팅한다.
2. /photo 는 photo service 로 라우팅한다.

## music & photo app 개발
Ingress Service를 테스트하기 위해서 python flask 기반의 간단한 애플리케이션을 개발하기로 했다.

### python flask app 개발
**music-app.py**
```python
#!/usr/bin/env python
# encoding: utf-8

import json
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return "Python Example Music Application"

@app.route('/music/play/<name>')
def play(name):
    return "Play Music : " + str(name)

@app.route('/music/info/<name>')
def info(name):
    return "Music Info : " + str(name)

app.run(host='0.0.0.0', port=8088)
```

**photo-app.py**
```python
#!/usr/bin/env python
# encoding: utf-8

import json
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return "Python Example Photo Application"

@app.route('/photo/down/<name>')
def download(name):
    return "Photo download : " + str(name)

@app.route('/photo/info/<name>')
def info(name):
    return "Photo Info : " + str(name)

app.run(host='0.0.0.0', port='8080')
```

dockerizing을 위해서 의존성 정보를 포함한 requirements.txt 파일을 준비한다.
```
flask
```

### dockerizing and minikube 저장소 등록
앞선 문서에서 이미 한번 도커라이징을 했으므로 Dockerfile에 대한 설명은 하지 않겠다.

**photo-app.py**용 Dockerfile
```Dockerfile
FROM python:3.8-slim-buster
WORKDIR /app
COPY ./requirements.txt /app/requirements.txt
RUN pip install -r requirements.txt
COPY . /app
ENTRYPOINT [ "python" ]
CMD ["photo-app.py"]
```

**music-app.py**용 Docekrfiel
```Dockerfile
FROM python:3.8-slim-buster
WORKDIR /app
COPY ./requirements.txt /app/requirements.txt
RUN pip install -r requirements.txt
COPY . /app
ENTRYPOINT [ "python" ]
CMD ["music-app.py"]
```

docker build 명령을 이용해서 docker image로 만들자.
```shell
$ docker build -t test/music:0.1 -t test/music:latest . 
$ docker build -t test/photo:0.1 -t test/photo:latest .
```

성공적으로 빌드 됐으나 이 이미지는 로컬 docker 저장소에 등록됐을 것이다. minikube는 독자적인 이미지 저장소를 사용하고 있기 때문에, minikube 이미지 저장소를 사용하도록 환경설정해야 한다.
```shell
$ eval $(minikube docker-env)
```
이렇게 환경 설정하고 다시 빌드하자. 아래와 같이 이미지가 등록됐으면 성공이다. 
```shell
docker images
REPOSITORY                                TAG               IMAGE ID       CREATED         SIZE
test/photo                                0.1               4b02d567824b   2 seconds ago   127MB
test/photo                                latest            4b02d567824b   2 seconds ago   127MB
test/music                                0.1               d4fbf6803220   6 seconds ago   127MB
test/music                                latest            d4fbf6803220   6 seconds ago   127MB
```

### App 배포하기
Deployment를 만들기 위한 매니패스트 파일을 만들었다. 파일의 이름은 각각 music-app.yaml, music-app.yaml이다.

**music-app.yaml**
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: music-app 
spec:
  selector:
    matchLabels:
      run: music-app 
  replicas: 2
  template:
    metadata:
      labels:
        run: music-app 
    spec:
      containers:
        - name: music-app
          image: test/music-app
          imagePullPolicy: Never
          ports:
            - containerPort: 80808
              protocol: TCP

```
**photo-app.yaml**
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: photo-app 
spec:
  selector:
    matchLabels:
      run: photo-app 
  replicas: 2
  template:
    metadata:
      labels:
        run: photo-app 
    spec:
      containers:
        - name: photo-app 
          image: test/photo
          imagePullPolicy: Never
          ports:
            - containerPort: 8080
              protocol: TCP
```

### NodePort Service 로 전개하기
우리의 목표는 NginX Ingress Controller를 이용해서 music service와 photo service를 라우팅하는 MSA 구조의 애플리케이션을 만드는 것이다.

이제 MSA music service와 photo service를 **NodePort Type service**로 실행시켜야 한다. 왜냐하면 Ingress controll는 각 서비스의 NodePort로 경로를 설정하기 때문이다.

이를 위해서 music-app과 photo-app을 NodePort로 실행하기 위한 매니패스트를 작성했다.
**music-service.yaml**
```yaml
apiVersion: v1
kind: Service
metadata:
  name: music-service 
spec:
  type: NodePort 
  selector:
    run: music-app
  ports:
    - port: 8088 
```

**photo-service.yaml**
```yaml
apiVersion: v1
kind: Service
metadata:
  name: photo-service
spec:
  type: NodePort 
  selector:
    run: photo-app
  ports:
    - port: 8080
```

두 개 service를 전개하고, service 상태를 확인해 보자.
```shell
$ kubectl apply -f photo-service.yaml 
$ kubectl apply -f music-service.yaml 
$ kubectl get svc
NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes      ClusterIP   10.96.0.1       <none>        443/TCP          7d2h
music-service   NodePort    10.98.53.97     <none>        8088:30846/TCP   3h16m
photo-service   NodePort    10.106.152.50   <none>        8080:32468/TCP   3h16m

```
## Ingress 생성하기
이제 NginX ingress controller를 이용해서 Kubernetes ingress를 만들어보자. **minikube addon** 명령을 이용해서 nginx ingress를 설치할 수 있다.
```shell
minikube addons enable ingress
```

NginX Ingress가 실행중인지 확인해보자.
```shell
$ kubectl get pods -n ingress-nginx
NAME                                       READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-w6ppt       0/1     Completed   0          15m
ingress-nginx-admission-patch-fhtc6        0/1     Completed   1          15m
ingress-nginx-controller-77669ff58-xdv92   1/1     Running     0          15m
```

### PATH 기반 라우팅
Ingress controller이 설치됐으니 music-service와 photo-service로 트래픽을 라우팅하도록 ingress 정책을 만들어보자. 
![PATH 기반 라우팅](https://docs.google.com/drawings/d/e/2PACX-1vRCSwT40nQPqIywbhbDh4EBIpOdbHVMJdJ9bNvp4E8gF8njQScAySv0VOTwGDNCxnMTNTk-bxSJcn-j/pub?w=657&h=709)

media-ingress.yaml 매니패스트 파일을 만들었다. 
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: media-ingress
spec:
  rules:
  - http:
      paths:
        - path: /music
          pathType: Prefix
          backend:
            service:
              name: music-service 
              port:
                number: 8088
        - path: /photo
          pathType: Prefix
          backend:
            service:
              name: photo-service 
              port:
                number: 8080
```
rules : 라우팅룰을 설정한다. 여기에서는 **path 기반**으로 라우팅을 설정했다. PATH가 /music로 시작되면 music-service, /photo 로 시작되면 photo-service로 라우팅하도록 했다.

Ingress를 실행해보자.
```yaml
kubectl apply -f media-ingress.yaml 
```

Ingress 정보는 **get ingress**로 확인할 수 있다.
```shell
$ kubectl get ingress                
NAME            CLASS   HOSTS   ADDRESS        PORTS   AGE
media-ingress   nginx   *       192.168.49.2   80      18m
```

우리가 원하는대로 라우팅이 되는지 테스트해보자.
```shell
$ curl 192.168.49.2/music/play/1234
Play Music : 1234

$curl 192.168.49.2/photo/down/flower
Photo download : flower
```

설정대로 잘 작동하는 걸 확인 할 수 있다. **describe ingress** 명령을 이용해서 ingress의 상세 정보를 확인 할 수 있다. 
```shell
$ kubectl describe ingress media-ingress
Name:             media-ingress
Labels:           <none>
Namespace:        default
Address:          192.168.49.2
Ingress Class:    nginx
Default backend:  <default>
Rules:
  Host        Path  Backends
  ----        ----  --------
  *           
              /music   music-service:8088 (10.244.0.53:8088,10.244.0.54:8088)
              /photo   photo-service:8080 (10.244.0.55:8080,10.244.0.56:8080)
Annotations:  <none>
Events:
  Type    Reason  Age                From                      Message
  ----    ------  ----               ----                      -------
  Normal  Sync    18m (x4 over 25m)  nginx-ingress-controller  Scheduled for sync
```

### 호스트 기반 라우팅
호스트 기반라우팅은 HTTP 헤더의 HOST 필드의 값을 이용용하는 라우팅 방식이다. 예를들어 요청 호스트이름이 photo.example.com 이라면 photo service로 라우팅하고, music.example.com 이라면 music service로 라우팅하도록 설정 할 수 있다.

![Host 기반 라우팅](https://docs.google.com/drawings/d/e/2PACX-1vRYBsJHUx0FkREueOH56eIjR_bmJIzRbTqhk0lADwIn_juQvHOVS0N9Xp1ijoph7ijKweUewAmzhQdr/pub?w=657&h=709)

아래는 호스트 기반 라우팅룰이 적용된 매니패스트 파일이다.
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: media-ingress
spec:
  rules:
    - host: "music.example.com"
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: music-service 
                port:
                  number: 8088
    - host: "photo.example.com"
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: photo-service 
                port:
                  number: 8080
```

Ingress를 새로 적용하고 curl로 테스트해보자.
```shell
$ curl --header "Host: music.example.com" 192.168.49.2/music/play/1234
Play Music : 1234

$curl --header "Host: photo.example.com" 192.168.49.2/photo/down/3333
Photo download : 3333
```

## 정리
이번 문서에서는 kubernetes ingress를 살펴봤다. 여기에서 우리가 배운 것은 다음과 같다.
1. kubernetes deployment 복습
2. kubernetes service 복습
3. kubernetes ingress의 개념
4. NginX ingress controller를 설치하여 HTTP 요청을 HOST 및 PATH 기반 라우팅 룰을 적용하여 라우팅.

다음 문서에서는 Kubernetes Helm을 살펴보겠다. 
## 참고
1. [NginX 인그레스 컨트롤러로 Minikube에서 인그레스 설정하기](https://kubernetes.io/ko/docs/tasks/access-application-cluster/ingress-minikube/)
2. [Kubernetes ingress, deep dive](https://banzaicloud.com/blog/k8s-ingress/)

Search For:

BY TAGS

Recent Posts

Archive Posts

Tags

About

Get in Touch

Categories