Ejercicio: Creación de un recurso HorizontalPodAutoscaler

15 minutos

Ejercicio: Escalado de una aplicación

Creación de un clúster de AKS

Para poder empezar a escalar la aplicación, debe crear un clúster de AKS con los recursos necesarios.

Inicie sesión en Azure Cloud Shell con la cuenta en la que desea implementar recursos y seleccione Bash como shell en ejecución.
Cree un grupo de recursos con el comando az group create. En el ejemplo siguiente se crea un grupo de recursos denominado myResourceGroup en la ubicación eastus:
```
az group create --name myResourceGroup --location eastus
```
Cree un clúster de AKS con el comando az aks create. En el siguiente ejemplo se crea un clúster denominado myAKSCluster en el grupo de recursos myResourceGroup. El clúster tiene un nodo y usa el tamaño de la máquina virtual 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
```
El comando tarda unos minutos en completarse.
Obtenga las credenciales del clúster mediante el comando az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Compruebe que el clúster se está ejecutando y que puede conectarse a él mediante el comando kubectl get nodes.
```
kubectl get nodes
```
El comando debe devolver un nodo con un estado de Ready.

Implementación de los recursos de la aplicación

Ahora que tiene un clúster, puede implementar la aplicación en él.

Implementación de la aplicación

Cree el espacio de nombres de la aplicación mediante el comando kubectl create namespace.
```
kubectl create namespace hpa-contoso
```

Cree un nuevo archivo denominado deployment.yml en el editor de Cloud Shell y pegue el siguiente código YAML en él:

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 el archivo.
Implemente la aplicación en el clúster mediante el comando kubectl apply.
```
kubectl apply -f deployment.yml
```
El resultado debería ser similar al ejemplo siguiente:
```
deployment.apps/contoso-website created
```

Creación de una zona DNS e implementación del recurso de entrada

Creación de una zona de Azure DNS mediante el comando az network dns zone create. En el siguiente ejemplo se crea una zona DNS denominada contoso-website.com:
```
az network dns zone create --resource-group myResourceGroup --name contoso-website.com
```
Obtenga el identificador de recurso de la zona DNS mediante el comando az network dns zone show y guarde la salida en una variable denominada DNS_ZONE_ID.
```
DNS_ZONE_ID=$(az network dns zone show --resource-group myResourceGroup --name contoso-website.com --query id --output tsv)
```
Actualice el complemento de clúster de enrutamiento de aplicaciones para habilitar la integración de Azure DNS mediante el comando az aks approuting zone.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${DNS_ZONE_ID} --attach-zones
```

Cree un archivo denominado ingress.yml en el editor de Cloud Shell y pegue el siguiente código YAML en él. Asegúrese de reemplazar el marcador de posición <dns-zone-name> por el nombre de la 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 el archivo.
Implemente el recurso de entrada en el clúster mediante el comando kubectl apply.
```
kubectl apply -f ingress.yml
```
El resultado debería ser similar al ejemplo siguiente:
```
ingress.networking.k8s.io/contoso-website created
```

Creación del recurso de servicio

Cree un archivo denominado service.yml en el editor de Cloud Shell y pegue el siguiente código YAML en él:

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

Guarde el archivo.
Implemente el recurso de servicio en el clúster mediante el comando kubectl apply.
```
kubectl apply -f service.yml
```
El resultado debería ser similar al ejemplo siguiente:
```
service/contoso-website created
```

Cree un HorizontalPodAutoscaler

Cree un archivo denominado hpa.yml en el editor de Cloud Shell y pegue el siguiente código YAML en él:
```
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
```
Es importante señalar que las claves scaleTargetRef deben ser las mismas que las del recurso de implementación creado. En su caso, la implementación que creó tiene el apiVersion como apps/v1 y se denomina contoso-website. Este HPA está configurado para consultar la métrica de CPU nativa. Si esta métrica supera el promedio del 20 % de una cantidad de tiempo especificada, se escala horizontalmente la implementación en una unidad. El algoritmo usado para calcular esta métrica se basa en esta ecuación matemática:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Las claves minReplicas y maxReplicas definen el número mínimo y máximo de réplicas que puede tener la implementación. La metrics clave define las métricas de las consultas de HPA para escalar la implementación. En este caso, HPA consulta las métricas de CPU y memoria. Si la métrica de CPU supera el 20 % o la métrica de memoria supera el 50 %, HPA escala horizontalmente la implementación.
Guarde el archivo.
Cree el HPA mediante el comando kubectl apply.
```
kubectl apply -f hpa.yml
```
El resultado debería ser similar al ejemplo siguiente:
```
horizontalpodautoscaler.autoscaling/contoso-website created
```

Comprobar los resultados

Consulte las métricas y el uso del HPA mediante el comando kubectl get hpa.
```
kubectl get hpa --namespace hpa-contoso
```
El resultado debería ser similar al ejemplo siguiente:
```
NAME              REFERENCE                    TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
contoso-website   Deployment/contoso-website   0%/20%, 0%/50%   1         10        1          83s
```
Observe la columna TARGETS. Muestra el uso actual de las métricas definidas en HPA. En este caso, el uso de la CPU es del 0 % y el uso de memoria es del 0 %. Esto se debe a que la aplicación no recibe tráfico.

Nota:

Es posible que el HPA muestre métricas unknown durante los primeros segundos cuando intenta llegar a la API de métricas para capturarlas desde el servidor.