Øvelse – Distribuer en mikrotjenestebeholder til Kubernetes

7 minutter

Kubernetes kjører beholdere for deg. Du beskriver hva du vil at Kubernetes skal gjøre gjennom en YAML-fil. Denne øvelsen veileder deg gjennom oppretting av filen, slik at du kan distribuere og kjøre serverdel-tjenesten på Kubernetes.

Viktig

Før du fortsetter, må du være sikker på at du har installert en Kubernetes-implementering. Vi skal bruke k3d implementering som kjører i kodeområdet. Vi starter laboratoriet ved å installere denne implementeringen.

Installer Kubernetes-verktøy og -implementering

Vi må installere både kubectl-verktøyet og k3d Kubernetes-implementering:

Bytt til fanen TERMINAL i kodeområdet, og kjør deretter disse kommandoene for å installere forutsetninger:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Hvis du vil laste ned signeringsnøkkelen for Kubernetes-pakkerepositorier, kjører du disse kommandoene:
```
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
```
Hvis du får en feilmelding om at katalogen allerede finnes, kjører du kommandoen curl separat.

Legg kubernetes-repositoriet til apt-konfigurasjonen:

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

Nå kan du installere verktøyet kubectl:

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

Til slutt installerer du k3d implementering av Kubernetes og oppretter en klynge:

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

Opprette en distribusjonsfil for serverdeltjenesten

Du kan opprette en filbehandlingsbeholderdistribusjon i Kubernetes med en YAML-fil. La oss opprette en fil for å distribuere serverdeltjenesten.

Opprett en ny fil i donet-kubernetes-mappen i kodeområdet backend-deploy.yml.

Kopier teksten nedenfor til filen, og lagre den.

---
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

Erstatt plassholderen [YOUR DOCKER USER NAME] med ditt faktiske Docker-brukernavn.

Denne filen gjør et par ting.

Den første delen definerer en distribusjonsspesifikasjon for beholderen som skal distribueres til Kubernetes. Den angir én replika, hvor du finner beholderbildet, hvilke porter som skal åpnes i beholderen, og angir noen miljøvariabler. Denne første delen definerer også etiketter og navn som kan brukes til å referere til beholderen og spesifikasjonen.

Den andre delen definerer deretter at beholderen kjører som en Kubernetes NodePort-tjeneste. For denne modulen trenger du ikke å forstå alle detaljene i NodePorts. Du bør imidlertid vite at denne typen tjeneste viser en ekstern IP-adresse, slik at du kan teste tjenesten fra utenfor klyngen.

Distribuere og kjøre mikrotjenesten for serverdel

Deretter distribuerer og kjører vi mikrotjenesten.

Kjør følgende kommando i TERMINAL-fanen:
```
kubectl apply -f backend-deploy.yml
```
Denne kommandoen ber Kubernetes om å kjøre filen vi opprettet. Det laster ned bildet fra Docker Hub og oppretter beholderen.
Kommandoen kubectl apply returnerer raskt. Men det kan ta litt tid å opprette beholderen. Hvis du vil vise fremdriften, bruker du følgende kode.
```
kubectl get pods
```
I resultatet har du en rad med productsbackend etterfulgt av en streng med tilfeldige tegn under kolonnen NAME. Når alt er klart, er det en 1/1 under READY-kolonnen og kjører under STATUS-kolonnen.
Hvis du vil teste tjenesten, bytter du til PORTS-fanen, i nærheten av den lokale adressen for Back End-porten, velger du globusikonet. Nettleseren åpner en ny fane på denne adressen.

Hvis du vil spørre noen produkter, tilføyer du adressen med /api/product og trykker deretter på ENTER. Du bør se noe produktinformasjon oppført i JSON-format.

[
    {
        "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"
    },
    ...

Opprette en distribusjonsfil og kjøre frontend-tjenesten

I likhet med serverdeltjenesten trenger vi også en distribusjonsfil for frontend.

Opprett en ny fil i donet-kubernetes-mappen med navnet frontend-deploy.yml

Lim inn følgende kode i filen:

---
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

Erstatt plassholderen [YOUR DOCKER USERNAME] med ditt faktiske Docker-brukernavn.

Legg merke til at denne filen ligner den vi opprettet for serverdelmikrotjenesten. Det er to forskjeller:
- Vi angir en annen beholder som skal kjøres under distribusjonens spec.template.spec.containers.image verdi.
- Det finnes en ny miljøvariabel under inndelingen spec.template.spec.containers.env. Koden i lagerfrontend-programmet kaller backend, men fordi vi ikke angir et fullstendig domenenavn (FQDN), vet vi ikke IP-adressen til serverdelmikrotjenesten, vi bruker navnet vi angav under metadata.name noden for Deployment. Kubernetes tar seg av resten.
Distribuer beholderen til Kubernetes med følgende kommando:
```
kubectl apply -f frontend-deploy.yml
```
Igjen kan du bruke kubectl get pods til å se statusen for distribusjonen. Når raden for lagerfrontend vises Kjører under kolonnen STATUS, er alt klart.
Hvis du vil teste fronttjenesten, bytter du til PORTS-fanen, og deretter velger du globusikonet til høyre for den lokale adressen for Front End port. Nettleseren viser hjemmesiden.
Velg Produkter. Katalogen viser Contosos varer.

I denne øvelsen opprettet du en distribusjonsfil som beskrev nøyaktig hvordan du ville at beholderne skulle kjøre i Kubernetes. Deretter fikk du Kubernetes til å laste ned bildet fra Docker Hub og starte beholderne.

Tilbakemeldinger

Var denne siden nyttig?