Ćwiczenie — wdrażanie kontenera mikrousług na platformie Kubernetes

7 min

Platforma Kubernetes uruchamia kontenery za Ciebie. Opisz, co chcesz, aby platforma Kubernetes robiła za pośrednictwem pliku YAML. W tym ćwiczeniu przedstawiono proces tworzenia pliku w celu wdrożenia i uruchomienia usługi zaplecza na platformie Kubernetes.

Ważny

Przed kontynuowaniem upewnij się, że masz zainstalowaną implementację platformy Kubernetes. Będziemy używać implementacji k3d uruchomionej w przestrzeni kodu. Rozpoczniemy laboratorium, instalując tę implementację.

Instalowanie narzędzi i implementacji platformy Kubernetes

Musimy zainstalować zarówno narzędzie kubectl , jak i implementację platformy Kubernetes k3d :

W przestrzeni kodu przejdź do karty TERMINAL , a następnie uruchom następujące polecenia, aby zainstalować wymagania wstępne:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Następnie, aby pobrać klucz podpisywania dla repozytoriów pakietów Kubernetes, uruchom następujące polecenia:
```
sudo mkdir /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
Jeśli zostanie wyświetlony błąd, że katalog już istnieje, uruchom polecenie curl oddzielnie.

Dodaj repozytorium Kubernetes do konfiguracji apt :

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Teraz możesz zainstalować narzędzie kubectl :

sudo apt-get update
sudo apt-get install -y kubectl

Na koniec zainstaluj implementację k3d platformy Kubernetes i utwórz klaster:

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

Tworzenie pliku wdrożenia dla usługi zaplecza

Możesz utworzyć plik do zarządzania wdrożeniem kontenera na platformie Kubernetes przy użyciu pliku YAML. Utwórzmy plik, aby wdrożyć usługę zaplecza.

Utwórz nowy plik w folderze donet-kubernetes przestrzeni kodu o nazwie backend-deploy.yml.

Skopiuj następujący tekst do pliku, a następnie zapisz go.

---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: productsbackend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: productsbackend
    spec:
      containers:
      - name: productsbackend
        image: [YOUR DOCKER USER NAME]/productservice:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
  selector:
    matchLabels:
      app: productsbackend
---
apiVersion: v1
kind: Service
metadata:
  name: productsbackend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32001
  selector:
    app: productsbackend

Zastąp symbol zastępczy [YOUR DOCKER USER NAME] rzeczywistą nazwą użytkownika platformy Docker.

Ten plik wykonuje kilka czynności.

Pierwsza część definiuje specyfikację wdrożenia kontenera, który ma zostać wdrożony na platformie Kubernetes. Określa jedną replikę, gdzie można znaleźć obraz kontenera, które porty mają być otwarte na kontenerze, i ustawia niektóre zmienne środowiskowe. Ta pierwsza część definiuje również etykiety i nazwy, których można użyć do odwołowania się do kontenera i specyfikacji.

Druga część definiuje następnie, że kontener działa jako usługa Kubernetes NodePort. W tym module nie musisz rozumieć wszelkich specyfik NodePorts. Należy jednak wiedzieć, że ten typ usługi uwidacznia zewnętrzny adres IP, aby można było przetestować usługę spoza klastra.

Wdrażanie i uruchamianie mikrousługi zaplecza

Następnie wdróżmy i uruchomimy mikrousługę.

Na karcie TERMINAL uruchom następujące polecenie:
```
kubectl apply -f backend-deploy.yml
```
To polecenie informuje platformę Kubernetes o uruchomieniu utworzonego pliku. Pobiera obraz z usługi Docker Hub i tworzy kontener.
Polecenie kubectl apply szybko powraca. Jednak tworzenie kontenera może chwilę potrwać. Aby wyświetlić postęp, użyj następującego kodu.
```
kubectl get pods
```
W wynikowych danych wyjściowych masz wiersz z productsbackend, po którym następuje ciąg losowych znaków w kolumnie NAME. Gdy wszystko jest gotowe, w kolumnie READY znajduje się 1/1, a Running w kolumnie STATUS.
Aby przetestować usługę, przejdź do karty PORTY w pobliżu adresu lokalnego portu zaplecza , wybierz ikonę globusa. Przeglądarka otwiera nową kartę pod tym adresem.

Aby wykonać zapytanie dotyczące niektórych produktów, dołącz adres za pomocą polecenia /api/product , a następnie naciśnij Enter. Powinny zostać wyświetlone informacje o produkcie w formacie JSON.

[
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...

Tworzenie pliku wdrożenia i uruchamianie usługi frontonu

Podobnie jak usługa zaplecza, potrzebujemy również pliku wdrożenia dla frontend.

Utwórz nowy plik w folderze donet-kubernetes o nazwie frontend-deploy.yml

Wklej następujący kod do pliku:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storefrontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: storefrontend
    spec:
      containers:
      - name: storefrontend
        image: [YOUR DOCKER USER NAME]/storeimage:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
        - name: ProductEndpoint
          value: http://productsbackend
  selector:
    matchLabels:
      app: storefrontend
---
apiVersion: v1
kind: Service
metadata:
  name: storefrontend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32000
  selector:
    app: storefrontend

Zastąp symbol zastępczy [YOUR DOCKER USERNAME] rzeczywistą nazwą użytkownika platformy Docker.

Zwróć uwagę, że ten plik jest podobny do tego, który utworzyliśmy dla mikrousługi zaplecza. Istnieją dwie różnice:
- Określamy inny kontener, który ma działać w ramach wdrożenia o wartości spec.template.spec.containers.image.
- W sekcji spec.template.spec.containers.env znajduje się nowa zmienna środowiskowa. Kod w aplikacji storefrontend wywołuje zaplecze, ale ponieważ nie określiliśmy w pełni kwalifikowanej nazwy domeny (FQDN), nie znamy adresu IP mikrousługi zaplecza, używamy nazwy określonej w węźle metadata.nameDeployment. Platforma Kubernetes zajmuje się resztą.
Wdróż kontener na platformie Kubernetes za pomocą następującego polecenia:
```
kubectl apply -f frontend-deploy.yml
```
Ponownie możesz użyć kubectl get pods, aby wyświetlić stan wdrożenia. Po wyświetleniu wiersza dla storefrontend, w kolumnie STATUS pojawi się Running, wszystko jest gotowe.
Aby przetestować usługę front-end, przejdź do karty PORTY , a następnie po prawej stronie przy adresie lokalnym dla portu front-end wybierz ikonę globusa. W przeglądarce zostanie wyświetlona strona główna.
Wybierz produkt . Katalog zawiera towary firmy Contoso.

W tym ćwiczeniu utworzono plik wdrożenia, który dokładnie opisał, jak kontenery mają być uruchamiane w ramach platformy Kubernetes. Następnie platforma Kubernetes pobiera obraz z usługi Docker Hub i uruchamia kontenery.

Sprzężenie zwrotne

Czy ta strona była pomocna?