Exercício - Crie o 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 AKS com os recursos necessários.

Entre na Azure Cloud Shell com a conta em que deseja implantar recursos e selecione Bash como shell em execução.
Crie um grupo de recursos usando o comando az group create. O exemplo a seguir cria um grupo de recursos chamado myResourceGroup no local eastus:
```
az group create --name myResourceGroup --location eastus
```
Crie um cluster AKS usando o comando az aks create. O exemplo a seguir cria um cluster chamado myAKSCluster no grupo de recursos myResourceGroup. O cluster tem um nó e utiliza o tamanho de 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
```
O comando leva alguns minutos para ser concluído.

Obtenha as credenciais para o 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 o status 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
```
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 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 o ID do recurso para 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 de cluster de roteamento de aplicativos para habilitar a integração do 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 o seguinte código YAML nele. Certifique-se de que substitui o marcador de posição <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
```
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 chamado 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

Salve o arquivo.
Implante o recurso de serviço no cluster usando o comando kubectl apply.
```
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 chamado 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 scaleTargetRef precisam ser as mesmas que o recurso de implantação criado. No seu caso, a implementação que criou tem o apiVersion como apps/v1 e é chamada de contoso-website. Este HPA está configurado para consultar a métrica nativa da CPU. Se essa métrica ultrapassar a sua média de 20% por um período de tempo especificado, ela escalará a implementaçã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 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 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%, o HPA dimensionará a implantação.
Salve o arquivo.
Crie o HPA usando o comando kubectl apply.
```
kubectl apply -f hpa.yml
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Veja os resultados

Consulte as métricas e o uso do HPA usando o comando kubectl get hpa.
```
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 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 nos primeiros segundos enquanto tenta aceder à API de métricas para as obter do servidor.