Distribuire applicazioni con Helm

  • Articolo

Si applica a: Servizio Azure Kubernetes in Azure Stack HCI 22H2, servizio Azure Kubernetes in Windows Server

Helm è uno strumento di creazione dei pacchetti open source che consente di installare e gestire il ciclo di vita delle applicazioni Kubernetes. Analogamente ai gestori pacchetti Linux, ad esempio APT e Yum, Helm gestisce i grafici Kubernetes, che sono pacchetti di risorse Kubernetes preconfigurati.

Questo articolo descrive come usare Helm per creare pacchetti e distribuire applicazioni nel servizio Azure Kubernetes quando si usa servizio Azure Kubernetes abilitato da Azure Arc.

Prima di iniziare

Verificare che siano configurati i requisiti seguenti:

  • Un cluster Kubernetes con almeno un nodo di lavoro Windows o Linux in esecuzione.
  • È stato configurato l'ambiente locale kubectl per puntare al cluster. È possibile usare il comando Get-AksHciCredential PowerShell per accedere al cluster usando kubectl.
  • Riga di comando Helm v3 e prerequisiti installati.
  • Registro contenitori disponibile, ad esempio DockerHub o Registro Azure Container.

In questo argomento viene usata un'applicazione ASP.NET Core come esempio. È possibile scaricare l'applicazione di esempio da questo repository GitHub.

Poiché l'applicazione viene distribuita in Kubernetes, l'esempio seguente è un dockerfile semplice per il progetto:

FROM mcr.microsoft.com/dotnet/aspnet:5.0-alpine AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:5.0-alpine AS build
WORKDIR /src
COPY ["MyMicroservice.csproj", "./"]
RUN dotnet restore "MyMicroservice.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "MyMicroservice.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyMicroservice.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyMicroservice.dll"]

Compilare e eseguire il push dell'applicazione di esempio in un registro contenitori

Passare alla cartella dell'applicazione e usare Dockerfile per compilare e eseguire il push di un'immagine usando il comando seguente:

docker build -f Dockerfile -t acr.azurecr.io/mymicroservice:0.1.0 .

Nota

Il punto (.) alla fine del comando imposta la posizione del Dockerfile (in questo caso, la directory corrente).

Questo comando crea l'immagine mymicroservice:0.1.0 nel computer locale. Per verificare che l'immagine sia stata creata correttamente, eseguire docker images per confermare.

REPOSITORY              TAG     IMAGE ID       CREATED            SIZE  
acr.azurecr.io/mymicroservice 0.1.0   5be713db571b   About a minute ago 107MB
....

Eseguire quindi il push dell'immagine in un registro contenitori, ad esempio DockerHub o Registro Azure Container. In questo esempio l'immagine del contenitore viene eseguita il push in Registro Azure Container (ACR). Per altre informazioni, vedere Eseguire il pull di immagini da un registro Azure Container a un cluster Kubernetes.

docker push acr.azurecr.io/mymicroservice:0.1.0

Creare il grafico Helm

Ora che l'applicazione di esempio è pronta, il passaggio successivo consiste nel generare un grafico Helm usando il helm create comando, come indicato di seguito:

helm create mymicroserviceapp

Aggiornare mymicroserviceapp/values.yaml, come segue:

  • Cambiare image.repository in acr.azurecr.io/mymicroservice.
  • Cambiare service.type in NodePort.

Ad esempio:

# Default values for webfrontend.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: acr.azurecr.io/mymicroservice
  pullPolicy: IfNotPresent
...
service:
  type: NodePort
  port: 80
...

Passare al file mymicroserviceapp/templates/deployment.yaml per configurare i controlli di integrità. Kubernetes usa i controlli di integrità per gestire le distribuzioni dell'applicazione. Sostituire il percorso di entrambi liveness i readiness probe con path: /weatherforecast, come illustrato nell'esempio seguente:

...
 livenessProbe:
    httpGet:
      path: /weatherforecast
      port: http
    initialDelaySeconds: 0
    periodSeconds: 10
    timeoutSeconds: 1
    failureThreshold: 3
 readinessProbe:
    httpGet:
      path: /weatherforecast
      port: http
    successThreshold: 3
...

Distribuire il grafico Helm in Kubernetes

A partire dalla directory chart\mymicroserviceapp nella directory della soluzione, eseguire il comando seguente:

helm upgrade --install mymicroserviceapp . --namespace=local --set mymicroserviceapp.image.tag="0.1.0"

Questo comando crea (o aggiorna) una versione esistente usando il nome mymicroserviceapp nello spazio dei nomi nel local cluster Kubernetes e produce output simile a questo esempio:

Release "mymicroserviceapp" does not exist. Installing it now.
NAME: mymicroserviceapp
LAST DEPLOYED: Fri Apr  2 08:47:24 2021
NAMESPACE: local
STATUS: deployed
REVISION: 1
NOTES:
1. Get the application URL by running these commands:
  export NODE_PORT=$(kubectl get --namespace local -o jsonpath="{.spec.ports[0].nodePort}" services mymicroserviceapp)
  export NODE_IP=$(kubectl get nodes --namespace local -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT

Dopo aver distribuito il grafico Helm, è possibile verificare che le risorse siano state distribuite correttamente eseguendo kubectl get all -n local.

L'output dall'esecuzione del comando è:

NAME                                     READY   STATUS    RESTARTS   AGE
pod/mymicroserviceapp-7849f949df-fwgbn   1/1     Running   0          101s

NAME                        TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
service/mymicroserviceapp   NodePort   10.100.149.1   <none>        80:30501/TCP   101s

NAME                                READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/mymicroserviceapp   1/1     1            1           101s

NAME                                           DESIRED   CURRENT   READY   AGE
replicaset.apps/mymicroserviceapp-7849f949df   1         1         1       101s

Testare la distribuzione

L'applicazione viene distribuita con un servizio e una porta del nodo, quindi è possibile chiamare l'API dall'esterno del cluster. Per effettuare questa chiamata, inviare una richiesta a: http://$NODE_IP:$NODE_PORT:

curl http://10.193.2.103:30501/WeatherForeCast/

StatusCode        : 200
StatusDescription : OK
Content           : [{"date":"2021-04-03T15:51:04.795216+00:00","temperatureC":45,"temperatureF":112,"summary":"Balmy"},{"date":"2021-04-04T15:51:04.
                    7952176+00:00","temperatureC":23,"temperatureF":73,"summary":"Cool"},{"...
RawContent        : HTTP/1.1 200 OK
                    Transfer-Encoding: chunked
                    Content-Type: application/json; charset=utf-8
                    Date: Fri, 02 Apr 2021 15:51:04 GMT
                    Server: Kestrel

                    [{"date":"2021-04-03T15:51:04.795216+00:00","tempera...
Forms             : {}
Headers           : {[Transfer-Encoding, chunked], [Content-Type, application/json; charset=utf-8], [Date, Fri, 02 Apr 2021 15:51:04 GMT], [Server,
                    Kestrel]}
Images            : {}
InputFields       : {}
Links             : {}
ParsedHtml        : mshtml.HTMLDocumentClass
RawContentLength  : 494

Pulire il cluster

Il passaggio finale consiste nel pulire il cluster. Per eliminare le risorse di distribuzione di Kubernetes, eseguire il comando seguente:

helm uninstall mymicroserviceapp -n local

L'output dovrebbe essere simile all'esempio seguente:

release "mymicroserviceapp" uninstalled

Passaggi successivi