Oefening: een microservicecontainer implementeren in Kubernetes

7 minuten

Kubernetes voert containers voor u uit. U beschrijft wat Kubernetes moet doen via een YAML-bestand. In deze oefening wordt uitgelegd hoe u het bestand maakt, zodat u de back-endservice op Kubernetes kunt implementeren en uitvoeren.

Belangrijk

Voordat u doorgaat, moet u ervoor zorgen dat u een Kubernetes-implementatie hebt geïnstalleerd. We gebruiken de k3d-implementatie die wordt uitgevoerd in de codespace. We starten het lab door deze implementatie te installeren.

Kubernetes-hulpprogramma's en -implementatie installeren

We moeten zowel het kubectl-hulpprogramma als de k3d Kubernetes-implementatie installeren:

Ga in de codespace naar het tabblad TERMINAL en voer vervolgens deze opdrachten uit om de vereisten te installeren:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Voer vervolgens de volgende opdrachten uit om de ondertekeningssleutel voor de Kubernetes-pakketopslagplaatsen te downloaden:
```
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
```
Als er een foutbericht wordt weergegeven dat de map al bestaat, voert u de curl opdracht afzonderlijk uit.

Voeg de Kubernetes-opslagplaats toe aan uw apt-configuratie :

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

U kunt nu het kubectl-hulpprogramma installeren:

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

Installeer ten slotte de k3d-implementatie van Kubernetes en maak een cluster:

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

Een implementatiebestand maken voor de back-endservice

U kunt een containerimplementatie in Kubernetes maken met een YAML-bestand. We gaan een bestand maken om de back-endservice te implementeren.

Maak een nieuw bestand in de map donet-kubernetes van de codespace met de naam backend-deploy.yml.

Kopieer de volgende tekst naar het bestand en sla deze op.

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

Vervang de tijdelijke aanduiding [YOUR DOCKER USER NAME] door uw werkelijke Docker-gebruikersnaam.

Dit bestand doet een aantal dingen.

Het eerste gedeelte definieert een implementatiespecificatie voor de container die in Kubernetes moet worden geïmplementeerd. Er wordt één replica opgegeven, waar de containerinstallatiekopieën moeten worden gevonden, welke poorten moeten worden geopend op de container en bepaalde omgevingsvariabelen worden ingesteld. Dit eerste gedeelte definieert ook labels en namen die kunnen worden gebruikt om te verwijzen naar de container en specificatie.

Het tweede gedeelte definieert vervolgens dat de container wordt uitgevoerd als een Kubernetes NodePort-service. Voor deze module hoeft u niet alle specifieke kenmerken van NodePorts te begrijpen. U moet echter weten dat dit type service een extern IP-adres beschikbaar maakt, zodat u de service van buiten het cluster kunt testen.

De back-endmicroservice implementeren en uitvoeren

Vervolgens gaan we de microservice implementeren en uitvoeren.

Voer op het tabblad TERMINAL de volgende opdracht uit:
```
kubectl apply -f backend-deploy.yml
```
Met deze opdracht wordt Kubernetes verteld het bestand uit te voeren dat we hebben gemaakt. De installatiekopieën worden gedownload uit Docker Hub en de container gemaakt.
De kubectl apply opdracht retourneert snel. Maar het maken van de container kan enige tijd duren. Gebruik de volgende code om de voortgang weer te geven.
```
kubectl get pods
```
In de resulterende uitvoer hebt u een rij met productsbackend gevolgd door een tekenreeks met willekeurige tekens onder de kolom NAME . Wanneer alles klaar is, bevindt zich een 1/1 onder de kolom READY en Wordt uitgevoerd onder de kolom STATUS .
Als u de service wilt testen, gaat u naar het tabblad POORTEN , in de buurt van het lokale adres voor de back-endpoort , selecteert u het wereldbolpictogram. De browser opent een nieuw tabblad op dat adres.

Als u een query wilt uitvoeren op sommige producten, voegt u het adres toe met /api/product en drukt u op Enter. Als het goed is, ziet u een aantal productgegevens in JSON-indeling.

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

Een implementatiebestand maken en de front-endservice uitvoeren

Net als de back-endservice hebben we ook een implementatiebestand nodig voor de front-end.

Maak een nieuw bestand in de map donet-kubernetes met de naam frontend-deploy.yml

Plak de volgende code in het bestand:

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

Vervang de tijdelijke aanduiding [YOUR DOCKER USERNAME] door uw werkelijke Docker-gebruikersnaam.

U ziet dat dit bestand vergelijkbaar is met het bestand dat we hebben gemaakt voor de back-end microservice. Er zijn twee verschillen:
- We geven een andere container op die moet worden uitgevoerd onder de waarde van spec.template.spec.containers.image de implementatie.
- Er is een nieuwe omgevingsvariabele in de spec.template.spec.containers.env sectie. De code in de storefrontend-toepassing roept de back-end aan, maar omdat we geen FQDN (Fully Qualified Domain Name) hebben opgegeven, weten we het IP-adres van de back-endmicroservice niet, gebruiken we de naam die we hebben opgegeven onder het knooppunt van het metadata.name Deployment. Kubernetes zorgt voor de rest.
Implementeer de container in Kubernetes met de volgende opdracht:
```
kubectl apply -f frontend-deploy.yml
```
Nogmaals, u kunt de kubectl get pods status van de implementatie bekijken. Zodra in de rij voor storefrontend Wordt uitgevoerd onder de kolom STATUS wordt weergegeven, is alles klaar om te gaan.
Als u de front-endservice wilt testen, gaat u naar het tabblad POORTEN en selecteert u rechts van het lokale adres voor de front-endpoort het wereldbolpictogram. In de browser wordt de startpagina weergegeven.
Selecteer Producten. In de catalogus ziet u de merchandise van Contoso.

In deze oefening hebt u een implementatiebestand gemaakt dat precies beschrijft hoe u de containers in Kubernetes wilt uitvoeren. Vervolgens hebt u Kubernetes de installatiekopieën uit Docker Hub gedownload en de containers gestart.

Doorgaan

Kubernetes-hulpprogramma's en -implementatie installeren

Een implementatiebestand maken voor de back-endservice

De back-endmicroservice implementeren en uitvoeren

Een implementatiebestand maken en de front-endservice uitvoeren

Feedback