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

7 min

Platforma Kubernetes uruchamia kontenery. Opisz, co chcesz, aby platforma Kubernetes robiła za pośrednictwem pliku YAML. W tym ćwiczeniu przedstawiono proces tworzenia pliku, dzięki czemu można wdrożyć i uruchomić usługę zaplecza na platformie Kubernetes.

Ważne

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 wystąpi błąd, że katalog już istnieje, uruchom curl polecenie 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óry porty mają być otwarte w 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ć wszystkich specyfiki węzłów 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 zwraca się szybko. 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 elementem productsbackend , po którym następuje ciąg losowych znaków w kolumnie NAME . Gdy wszystko jest gotowe, w kolumnie READY (GOTOWE) znajduje się 1/1 i Running (Uruchomione) w kolumnie STATUS (STAN).
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 klawisz 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 frontonu.

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

Wklej poniższy 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. Występuję dwie różnice:
- Określamy inny kontener do uruchomienia w ramach wartości wdrożenia spec.template.spec.containers.image .
- W sekcji znajduje się nowa zmienna środowiskowa spec.template.spec.containers.env . 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.name Deployment. 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 polecenia , aby wyświetlić stan wdrożenia. Po wyświetleniu wiersza dla sklepu storefrontend w kolumnie STATUS wszystko jest gotowe do przejścia.
Aby przetestować usługę frontonu, przejdź do karty PORTY , a następnie po prawej stronie adresu lokalnego dla portu frontonu wybierz ikonę globusa. W przeglądarce zostanie wyświetlona strona główna.
Wybierz produkty. 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.

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

Instalowanie narzędzi i implementacji platformy Kubernetes

Tworzenie pliku wdrożenia dla usługi zaplecza

Wdrażanie i uruchamianie mikrousługi zaplecza

Tworzenie pliku wdrożenia i uruchamianie usługi frontonu

Opinia