Implante o AHPA para previsão inteligente e pré-aquecimento de recursos a fim de resolver a latência de elasticidade do serviço - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Pré-requisitos

Antes de começar, verifique se você possui:

Um cluster gerenciado ACK ou um cluster ACK Serverless. Caso contrário, consulte Crie um cluster gerenciado ACK ou Crie um cluster ACK Serverless.
O Managed Service for Prometheus ativado no cluster. Se não estiver ativado, consulte Conectar e configure o Managed Service for Prometheus.
Pelo menos sete dias de estatísticas da aplicação coletadas pelo Prometheus, incluindo dados de uso de CPU e memória. O AHPA necessita desses dados históricos para gerar previsões. Se sua instância do Prometheus foi ativada recentemente, aguarde sete dias antes de prosseguir para a Etapa 4: Implantar o AHPA.

Etapa 1: Instale o controlador AHPA

Faça login no console ACK. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique em no nome do cluster que deseja gerenciar. No painel de navegação à esquerda, clique em Add-ons.
Na página Add-ons, localize o cartão AHPA Controller e clique em Install. Siga as instruções na tela para concluir a instalação.

Etapa 2: Configure o Prometheus como source de dados

Faça login no console ARMS.
No painel de navegação à esquerda, escolha Managed Service for Prometheus > Instances.
Na página Instances, selecione a região onde sua instância do Prometheus está implantada e clique em no nome da instância. O nome da instância corresponde ao nome do seu cluster ACK.
Na página Settings, localize a seção HTTP API URL (Grafana Read URL) e anote o endpoint interno. Se os tokens de acesso estiverem ativados no seu cluster, anote também o token de acesso.

Crie um arquivo chamado application-intelligence.yaml com o conteúdo a seguir. Substitua os espaços reservados pelo endpoint real do Prometheus e pelo token de acesso.

Para visualize métricas do Prometheus Service no painel do AHPA, adicione os seguintes parâmetros ao ConfigMap: prometheus_writer_url (endpoint interno para Remote Write), prometheus_writer_ak (AccessKey ID) e prometheus_writer_sk (AccessKey secret). Para mais detalhes, consulte Ative o painel do Prometheus para AHPA .

Espaço reservado	Descrição
`prometheusUrl`	Endpoint interno da sua instância do Prometheus
`token`	Token de acesso da sua instância do Prometheus. Necessário apenas se os tokens de acesso estiverem ativados

apiVersion: v1
kind: ConfigMap
metadata:
  name: application-intelligence
  namespace: kube-system
data:
  prometheusUrl: "http://cn-hangzhou-intranet.arms.aliyuncs.com:9443/api/v1/prometheus/da9d7dece901db4c9fc7f5b9c40****/158120454317****/cc6df477a982145d986e3f79c985a****/cn-hangzhou"
  token: "eyJhxxxxx"

Aplique o ConfigMap:

kubectl apply -f application-intelligence.yaml

Etapa 3: Implantar um serviço de teste

Esta etapa implanta um ambiente de teste para comparar o dimensionamento preditivo do AHPA com o comportamento padrão do Horizontal Pod Autoscaler (HPA). O ambiente consiste em:

fib-deployment: carga de trabalho alvo
fib-svc: Service que roteia o tráfego para fib-deployment
fib-loader: gerador de carga que simula flutuação de tráfego
fib-hpa: política HPA para fornecer uma linha de base para comparação

Crie um arquivo chamado demo.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: fib-deployment
  namespace: default
  annotations:
    k8s.aliyun.com/eci-use-specs: "1-2Gi"
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fib-deployment
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: fib-deployment
    spec:
      containers:
      - image: registry.cn-huhehaote.aliyuncs.com/kubeway/knative-sample-fib-server:20200820-171837
        imagePullPolicy: IfNotPresent
        name: user-container
        ports:
        - containerPort: 8080
          name: user-port
          protocol: TCP
        resources:
          limits:
            cpu: "1"
            memory: 2000Mi
          requests:
            cpu: "1"
            memory: 2000Mi
---
apiVersion: v1
kind: Service
metadata:
  name: fib-svc
  namespace: default
spec:
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: fib-deployment
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: fib-loader
  namespace: default
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: fib-loader
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: fib-loader
    spec:
      containers:
      - args:
        - -c
        - |
          /ko-app/fib-loader --service-url="http://fib-svc.${NAMESPACE}?size=35&interval=0" --save-path=/tmp/fib-loader-chart.html
        command:
        - sh
        env:
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.namespace
        image: registry.cn-huhehaote.aliyuncs.com/kubeway/knative-sample-fib-loader:20201126-110434
        imagePullPolicy: IfNotPresent
        name: loader
        ports:
        - containerPort: 8090
          name: chart
          protocol: TCP
        resources:
          limits:
            cpu: "8"
            memory: 16000Mi
          requests:
            cpu: "2"
            memory: 4000Mi
---
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: fib-hpa
  namespace: default
spec:
  maxReplicas: 50
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: fib-deployment
  targetCPUUtilizationPercentage: 50

Aplique a configuração:

kubectl apply -f demo.yaml

Etapa 4: Implantar o AHPA

Inicie o AHPA no modo observer. Nesse modo, o AHPA registra suas previsões de dimensionamento, mas não age sobre elas. Isso permite verifique a precisão das previsões antes de ative o dimensionamento automático.

Crie um arquivo chamado ahpa-demo.yaml com o seguinte conteúdo:

apiVersion: autoscaling.alibabacloud.com/v1beta1
kind: AdvancedHorizontalPodAutoscaler
metadata:
  name: ahpa-demo
spec:
  scaleStrategy: observer          # Start in observer mode to verify predictions first
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 40     # Scale when average CPU utilization exceeds 40%
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: fib-deployment
  maxReplicas: 100
  minReplicas: 2
  stabilizationWindowSeconds: 300  # Wait 300s after a scale-in signal before acting, to prevent flapping
  prediction:
    quantile: 0.95                 # Confidence level: 95% of historical peaks will be covered
    scaleUpForward: 180            # Start scaling 180s early to cover pod cold start time
  instanceBounds:
  - startTime: "2021-12-16 00:00:00"
    endTime: "2031-12-16 00:00:00"
    bounds:
    - cron: "* 0-8 ? * MON-FRI"
      maxReplicas: 15
      minReplicas: 4
    - cron: "* 9-15 ? * MON-FRI"
      maxReplicas: 15
      minReplicas: 10
    - cron: "* 16-23 ? * MON-FRI"
      maxReplicas: 20
      minReplicas: 15

A tabela a seguir descreve os principais parâmetros.

Parâmetro	Obrigatório	Padrão	Descrição
`scaleTargetRef`	Sim	—	Deployment ao qual aplicar o dimensionamento preditivo
`metrics`	Sim	—	Métricas que acionam o dimensionamento. Suportadas: CPU, GPU, memória, consultas por segundo (QPS) e tempo de resposta (RT)
`target.averageUtilization`	Sim	—	Limiar de utilização para acionar o dimensionamento. Por exemplo, `40` aciona o dimensionamento quando a utilização média da CPU excede 40%
`scaleStrategy`	Não	`observer`	Modo de dimensionamento. Consulte a tabela abaixo para valores válidos
`maxReplicas`	Sim	—	Número máximo de réplicas de pods
`minReplicas`	Sim	—	Número mínimo de réplicas de pods
`stabilizationWindowSeconds`	Não	`300`	Tempo de resfriamento das atividades de redução de escala, em segundos
`prediction.quantile`	Sim	`0.99`	Nível de confiança para previsões, expresso como quantil. Um valor mais alto gera previsões mais conservadoras, com maior probabilidade de provisionar capacidade suficiente antecipadamente. Valores válidos: `0`–`1`, com precisão de duas casas decimais. Valores entre `0.90` e `0.99` são recomendados para a maioria das cargas de trabalho
`prediction.scaleUpForward`	Sim	—	Segundos antes de um pico de demanda previsto em que o AHPA inicia o dimensionamento. Defina este valor para corresponder à duração do cold-start do pod (tempo desde a criação do pod até o estado Ready)
`instanceBounds`	Não	—	Duração de uma operação de dimensionamento. O número de pods replicados é limitado pelos valores máximo e mínimo definidos pelo AHPA
`instanceBounds.startTime`	Não	—	Hora de início para a regra de limites da instância
`instanceBounds.endTime`	Não	—	Hora de término para a regra de limites da instância
`instanceBounds.bounds.cron`	Não	—	Expressão cron que define quando os limites de réplica se aplicam

O campo scaleStrategy aceita os seguintes valores:

Valor	Descrição
`observer`	Registra previsões sem realizar nenhum dimensionamento. Use para validar o comportamento do AHPA antes de entrar em produção
`auto`	O AHPA executa operações de dimensionamento automaticamente
`proactive`	Aplica apenas dimensionamento preditivo com base em padrões históricos
`reactive`	Aplica apenas dimensionamento orientado por métricas, semelhante ao HPA padrão

Formato da expressão Cron

O campo instanceBounds.bounds.cron utiliza o seguinte formato de cinco campos:

Campo	Obrigatório	Valores válidos	Caracteres especiais
Minutos	Sim	0–59	`*/,-`
Horas	Sim	0–23	`*/,-`
Dia do mês	Sim	1–31	`*/,-?`
Mês	Sim	1–12 ou JAN–DEC	`*/,-`
Dia da semana	Não	0–6 ou SUN–SAT	`*/,-?`

Caracteres especiais: * (qualquer valor), / (incremento), , (separador de lista), - (intervalo), ? (espaço reservado).

Os campos Mês e Dia da semana não diferenciam maiúsculas de minúsculas (SUN, Sun, sun são equivalentes). Se o Dia da semana for omitido, o padrão será *.

Para obter mais informações sobre a sintaxe de expressões cron, consulte Expressões Cron.

Aplique a política do AHPA:
```
kubectl apply -f ahpa-demo.yaml
```

Etapa 5: Verifique previsões e ative o dimensionamento automático

O AHPA gera previsões com base nos últimos sete dias de dados históricos. Após aplicar a política, aguarde sete dias para acumular previsões. Para aplicar uma política do AHPA a uma aplicação existente, especifique a aplicação nas configurações da política do AHPA.

Durante o período de acumulação de sete dias, confirme se a configuração está funcionando corretamente:

# Check the AHPA object status
kubectl describe advancedhorizontalpodautoscaler ahpa-demo

# Watch the predicted replica count update over time
kubectl get advancedhorizontalpodautoscaler ahpa-demo -w

Após sete dias, revise os resultados das previsões usando o painel do Prometheus. Para obter instruções de configuração, consulte Ative o painel do Prometheus para AHPA.

Neste exemplo, o AHPA é executado no modo observer juntamente com a linha de base do HPA. O painel mostra dois gráficos de comparação:

Uso de CPU: A linha verde mostra o uso real da CPU (orientado pelo HPA). A linha amarela mostra o uso de CPU previsto pelo AHPA.
- O valor previsto é superior ao real, indicando que o AHPA provisiona capacidade suficiente antecipadamente.
- O valor previsto atinge o pico antes do valor real, confirmando que os recursos estão prontos antes da chegada da demanda.
Contagem de pods: A linha verde mostra os pods reais provisionados pelo HPA. A linha amarela mostra a contagem de pods prevista pelo AHPA.
- A contagem prevista de pods (amarela) é menor que a contagem do HPA (verde), pois o AHPA suaviza picos de curta duração.
- A curva amarela é mais suave que a curva verde; menos mudanças abruptas melhoram a estabilidade da carga de trabalho.

Ative dimensionamento automático

Quando as previsões corresponderem às suas expectativas, alterne o AHPA do modo observer para o modo auto. Edite o arquivo ahpa-demo.yaml e altere o scaleStrategy:

scaleStrategy: auto

Em seguida, aplique a alteração:

kubectl apply -f ahpa-demo.yaml

Agora o AHPA dimensiona automaticamente o fib-deployment usando dimensionamento preditivo.

Container Service for Kubernetes:Implantar AHPA