Exercício - Crie o seu HorizontalPodAutoscaler

15 minutos

Exercício - Dimensionamento de um aplicativo

Criar um cluster do AKS

Antes de começar a dimensionar seu aplicativo, você precisa criar um cluster AKS com os recursos necessários.

Entre no Azure Cloud Shell com a conta na qual você deseja implantar recursos e selecione Bash como o shell em execução.
Crie um grupo de recursos usando o az group create comando. O exemplo seguinte cria um grupo de recursos com o nome myResourceGroup na localização eastus:
```
az group create --name myResourceGroup --location eastus
```
Crie um cluster AKS usando o az aks create comando. O exemplo a myResourceGroup seguir cria um cluster nomeado myAKSCluster no grupo de recursos. O cluster tem um nó e usa o tamanho da Standard_DS2_v2 VM.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
O comando demora poucos minutos a concluir.

Obtenha as credenciais para o cluster usando o az aks get-credentials comando.

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Verifique se o cluster está em execução e se você pode se conectar a ele usando o kubectl get nodes comando.
```
kubectl get nodes
```
O comando deve retornar um nó com um status de Ready.

Implantar os recursos do aplicativo

Agora que você tem um cluster, pode implantar o aplicativo nele.

Implementar a aplicação

Crie o namespace do aplicativo usando o kubectl create namespace comando.
```
kubectl create namespace hpa-contoso
```

Crie um novo arquivo nomeado deployment.yml no editor do Cloud Shell e cole o seguinte código YAML nele:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  replicas: 1
  selector:
    matchLabels:
      app: contoso-website
  template:
    metadata:
      labels:
        app: contoso-website
    spec:
      containers:
        - name: contoso-website
          image: mcr.microsoft.com/mslearn/samples/contoso-website
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80

Guarde o ficheiro.
Implante o aplicativo no cluster usando o kubectl apply comando.
```
kubectl apply -f deployment.yml
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
deployment.apps/contoso-website created
```

Criar uma zona DNS e implantar o recurso de entrada

Crie uma zona DNS do Azure usando o az network dns zone create comando. O exemplo a seguir cria uma zona DNS chamada contoso-website.com:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Obtenha o ID do recurso para sua zona DNS usando o az network dns zone show comando e salve a saída em uma variável chamada DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Atualize o complemento de cluster de roteamento de aplicativos para habilitar a integração do DNS do Azure usando o az aks approuting zone comando.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Crie um arquivo nomeado ingress.yml no editor do Cloud Shell e cole o seguinte código YAML nele. Certifique-se de substituir o espaço reservado <dns-zone-name> pelo nome da sua zona DNS.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: contoso-website
  namespace: hpa-contoso
  annotations:
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <dns-zone-name>
    http:
      paths:
      - backend:
          service:
            name: contoso-website
            port:
              number: 80
        path: /
        pathType: Prefix

Guarde o ficheiro.
Implante o recurso de entrada no cluster usando o kubectl apply comando.
```
kubectl apply -f ingress.yml
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
ingress.networking.k8s.io/contoso-website created
```

Criar o recurso de serviço

Crie um arquivo nomeado service.yml no editor do Cloud Shell e cole o seguinte código YAML nele:

apiVersion: v1
kind: Service
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: contoso-website

Guarde o ficheiro.
Implante o recurso de serviço no cluster usando o kubectl apply comando.
```
kubectl apply -f service.yml
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
service/contoso-website created
```

Criar um HorizontalPodAutoscaler

Crie um arquivo nomeado hpa.yml no editor do Cloud Shell e cole o seguinte código YAML nele:
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: contoso-website
  namespace: hpa-contoso
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: contoso-website
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 20
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 50
```
É importante salientar que as chaves precisam ser as scaleTargetRef mesmas que o recurso de implantação criado. No seu caso, a implantação que você criou tem o apiVersion como apps/v1 e é chamada contoso-websitede . Este HPA está configurado para consultar a métrica nativa da CPU. Se essa métrica ultrapassar sua média de 20% por um período de tempo especificado, ela dimensionará a implantação em uma unidade. O algoritmo utilizado para calcular esta métrica baseia-se nesta equação matemática:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
As minReplicas chaves e definem o número mínimo e maxReplicas máximo de réplicas que a implantação pode ter. A metrics chave define as métricas que o HPA consulta para dimensionar a implantação. Nesse caso, o HPA consulta as métricas de CPU e memória. Se a métrica da CPU for superior a 20% ou a métrica de memória for superior a 50%, a HPA dimensionará a implantação.
Guarde o ficheiro.
Crie o HPA usando o kubectl apply comando.
```
kubectl apply -f hpa.yml
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Verificar os resultados

Consulte as métricas e o uso do HPA usando o kubectl get hpa comando.
```
kubectl get hpa --namespace hpa-contoso
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Observe a TARGETS coluna. Ele mostra o uso atual das métricas definidas no HPA. Nesse caso, o uso da CPU é de 0% e o uso de memória é de 0%. Isso ocorre porque o aplicativo não está recebendo nenhum tráfego.

Nota

É possível que o HPA mostre unknown métricas nos primeiros segundos enquanto tenta alcançar a API de métricas para buscá-las no servidor.