Exercício – Criar seu HorizontalPodAutoscaler

15 minutos

Exercício – Dimensionamento de um aplicativo

Criar um cluster AKS

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

Entre no Azure Cloud Shell com a conta na qual deseja implantar recursos e selecione Bash como o shell em execução.
Crie um grupo de recursos usando o comando az group create. O exemplo a seguir cria um grupo de recursos denominado myResourceGroup no local eastus:
```
az group create --name myResourceGroup --location eastus
```
Crie um cluster do AKS usando o comando az aks create. No exemplo a seguir, um cluster chamado myAKSCluster é criado no grupo de recursos myResourceGroup. O cluster tem um nó e usa o tamanho da VM Standard_DS2_v2.
```
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --node-vm-size Standard_DS2_v2 --enable-app-routing --generate-ssh-keys
```
Esse comando leva alguns minutos para ser concluído.

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

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 comando kubectl get nodes.
```
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.

Implantar o aplicativo

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

Crie um novo arquivo chamado 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

Salve o arquivo.
Implante o aplicativo no cluster usando o comando kubectl apply.
```
kubectl apply -f deployment.yml
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
deployment.apps/contoso-website created
```

Criar uma zona DNS e implantar o recurso de entrada

Criar uma zona DNS do Azure usando o comando az network dns zone create. 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 a ID do recurso da sua zona DNS usando o comando az network dns zone show 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 do cluster de roteamento de aplicativos para habilitar a integração com o DNS do Azure usando o comando az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Crie um arquivo chamado ingress.yml no editor do Cloud Shell e cole nele o código YAML a seguir. Substitua 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

Salve o arquivo.
Implante o recurso de entrada no cluster usando o comando kubectl apply.
```
kubectl apply -f ingress.yml
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
ingress.networking.k8s.io/contoso-website created
```

Criar o recurso de serviço

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

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

Salve o arquivo.
Implante o recurso de serviço no cluster usando o comando kubectl apply.
```
kubectl apply -f service.yml
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
service/contoso-website created
```

Criar um HorizontalPodAutoscaler

Crie um arquivo chamado hpa.yml no editor do Cloud Shell e cole nele o código YAML a seguir:
```
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 ressaltar que as chaves scaleTargetRef precisam ser as mesmas que o recurso de implantação criado. No seu caso, a implantação que você criou tem a apiVersion como apps/v1 e é chamada de contoso-website. Esse HPA está configurado para consultar a métrica de CPU nativa. Se essa métrica ultrapassar sua média de 20% para um período especificado, ela irá expandir a implantação em uma unidade. O algoritmo usado para calcular essa métrica se baseia nesta equação matemática:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
As chaves minReplicas e maxReplicas definem o número mínimo e máximo de réplicas que a implantação pode ter. A chave metrics define as métricas que o HPA irá consultar para dimensionar a implantação. Nesse caso, o HPA irá consultar as métricas de CPU e memória. Se a métrica da CPU ultrapassar 20% ou a métrica de memória ultrapassar 50%, o HPA dimensionará a implantação.
Salve o arquivo.
Crie o HPA usando o comando kubectl apply.
```
kubectl apply -f hpa.yml
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Verificar os resultados

Consulte as métricas e o uso do HPA usando o comando kubectl get hpa.
```
kubectl get hpa --namespace hpa-contoso
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Observe a coluna TARGETS. 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.

Observação

É possível que o HPA mostre métricas unknown pelos primeiros segundos, uma vez que ele está tentando acessar a API de métricas para buscá-las do servidor.