Övning – Distribuera en mikrotjänstcontainer till Kubernetes

7 minuter

Kubernetes kör containrar åt dig. Du beskriver vad du vill att Kubernetes ska göra via en YAML-fil. Den här övningen beskriver hur du skapar filen så att du kan distribuera och köra serverdelstjänsten på Kubernetes.

Viktig

Innan du fortsätter måste du vara säker på att du har en Kubernetes-implementering installerad. Vi kommer att använda k3d-implementeringen som körs i kodområdet. Vi startar labbet genom att installera den här implementeringen.

Installera Kubernetes-verktyg och implementering

Vi måste installera både kubectl-verktyget och k3d Kubernetes-implementeringen:

I kodområdet växlar du till fliken TERMINAL och kör sedan dessa kommandon för att installera förutsättningar:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Kör sedan följande kommandon för att ladda ned signeringsnyckeln för Kubernetes-paketlagringsplatserna:
```
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
```
Om du får ett felmeddelande om att katalogen redan finns kör du kommandot curl separat.

Lägg till Kubernetes-lagringsplatsen i din apt-konfiguration :

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

Nu kan du installera kubectl-verktyget :

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

Installera slutligen k3d-implementeringen av Kubernetes och skapa ett kluster:

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

Skapa en distributionsfil för serverdelstjänsten

Du kan skapa en containerdistribution i Kubernetes med en YAML-fil. Låt oss skapa en fil för att distribuera backendtjänsten.

Skapa en ny fil i mappen donet-kubernetes i kodområdet med namnet backend-deploy.yml.

Kopiera följande text till filen och spara den sedan.

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

Ersätt platshållaren [YOUR DOCKER USER NAME] med ditt faktiska Docker-användarnamn.

Den här filen gör ett par saker.

Den första delen definierar en distributionsspecifikation för containern som ska distribueras till Kubernetes. Den anger en replik, var containeravbildningen ska hittas, vilka portar som ska öppnas i containern, och vissa miljövariabler anges. Den första delen definierar också etiketter och namn som kan användas för att referera till containern och specifikationen.

Den andra delen definierar sedan att containern körs som en Kubernetes NodePort-tjänst. För den här modulen behöver du inte förstå alla detaljer i NodePorts. Du bör dock veta att den här typen av tjänst exponerar en extern IP-adress så att du kan testa tjänsten utanför klustret.

Distribuera och köra serverdelsmikrotjänsten

Nu ska vi distribuera och köra mikrotjänsten.

Kör följande kommando på fliken TERMINAL :
```
kubectl apply -f backend-deploy.yml
```
Det här kommandot uppmanar Kubernetes att köra filen som vi skapade. Den laddar ned avbildningen från Docker Hub och skapar containern.
Kommandot kubectl apply returnerar snabbt. Men det kan ta en stund att skapa containern. Om du vill visa förloppet använder du följande kod.
```
kubectl get pods
```
I de resulterande utdata har du en rad med productsbackend följt av en sträng med slumpmässiga tecken under kolumnen NAME . När allt är klart finns det en 1/1 under kolumnen READY och under kolumnen STATUS står det Körs.
Om du vill testa tjänsten växlar du till fliken PORTar , nära den lokala adressen för backend-porten och väljer jordglobsikonen. Webbläsaren öppnar en ny flik på den adressen.

Om du vill fråga efter vissa produkter lägger du till adressen med /api/product och trycker sedan på Retur. Du bör se viss produktinformation 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"
    },
    ...

Skapa en distributionsfil och kör klientdelstjänsten

Precis som serverdelstjänsten behöver vi även en distributionsfil för klientdelen.

Skapa en ny fil i mappen donet-kubernetes med namnet frontend-deploy.yml

Klistra in följande kod 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

Ersätt platshållaren [YOUR DOCKER USERNAME] med ditt faktiska Docker-användarnamn.

Observera att den här filen liknar den som vi skapade för serverdelsmikrotjänsten. Det finns två skillnader:
- Vi anger en annan container som ska köras för distribueringens spec.template.spec.containers.image-värde.
- Det finns en ny miljövariabel under avsnittet spec.template.spec.containers.env. Koden i storefrontend-programmet anropar serverdelen, men eftersom vi inte angav ett fullständigt domännamn (FQDN) känner vi inte till IP-adressen för serverdelsmikrotjänsten, vi använder det namn som vi angav under metadata.name noden i Deployment. Kubernetes tar hand om resten.
Distribuera containern till Kubernetes med följande kommando:
```
kubectl apply -f frontend-deploy.yml
```
Återigen kan du använda kubectl get pods för att se status för distributionen. När raden för storefrontend visas Körs under kolumnen STATUS är allt klart.
Om du vill testa Front End-tjänsten, växla till fliken PORTar och välj sedan globikonen till höger om den lokala adressen för Front End-porten. Webbläsaren visar startsidan.
Välj Produkter. Katalogen visar Contosos varor.

I den här övningen skapade du en distributionsfil som beskrev exakt hur du ville att containrarna skulle köras i Kubernetes. Sedan fick du Kubernetes att ladda ned avbildningen från Docker Hub och starta containrarna.

Feedback

Var den här sidan till hjälp?