Monitoramento de aplicações Python - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Para aplicações Python implantadas em clusters ACK, como aplicações web desenvolvidas com frameworks como Django, Flask e FastAPI, ou aplicações de IA e LLM criadas com LlamaIndex e Langchain, use o Application Real-Time Monitoring Service (ARMS) para monitorar o desempenho da aplicação. Para ativar o monitoramento, instale o componente ack-onepilot e modifique seu Dockerfile. Essa configuração habilita recursos como topologia de aplicação, rastreamento, análise de chamadas de API, detecção de anomalias e acompanhamento detalhado de interações com modelos grandes.

Pré-requisitos

Crie um namespace. Para mais informações, consulte Manage namespaces and resource quotas. Este tópico usa o namespace arms-demo como exemplo.
O runtime Python deve ser a versão 3,8 ou superior.

O ARMS é compatível com Python 3,8 e versões posteriores. O uso de uma versão anterior pode causar problemas de conexão.
Activate ARMS.

O ARMS é um service de gerenciamento de desempenho de aplicações (APM) fornecido pela Alibaba Cloud. Para obter mais detalhes sobre o monitoramento de aplicações, consulte What is Application Real-Time Monitoring Service (ARMS)? e What is application monitoring?.

Etapa 1: Instalar o componente ack-onepilot

Importante

O componente legado arms-pilot não recebe mais manutenção. O ack-onepilot é seu substituto e oferece total compatibilidade. A migração não exige alterações na configuração da sua aplicação. Para obter as etapas de migração, consulte Uninstall arms-pilot and install ack-onepilot.

Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do cluster. No painel de navegação à esquerda, clique em Components and Add-ons .
Na seção Logs and Monitoring, localize o add-on ack-onepilot e clique em Install no cartão do add-on.

Nota
Certifique-se de que a versão do ack-onepilot seja 3.2.4 ou superior. Por padrão, o componente ack-onepilot suporta até 1.000 pods. Para cada 1.000 pods adicionais acima desse limite, aumente os recursos de cpu do ack-onepilot em 0,5 núcleo e a memória em 512 MB.

Após a instalação, atualize, configure ou desinstale o add-on ack-onepilot na página Add-ons.

Etapa 2: Autorizar o ARMS a acessar recursos

O ARMS usa addon.arms.token para autorização sem senha. A maioria dos clusters gerenciados pelo ACK inclui esse secret por padrão, mas alguns clusters mais antigos podem não incluí-lo.

Verifique se o cluster possui o token:

Verificar o secret addon.arms.token no cluster

Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do cluster desejado. No painel de navegação à esquerda, escolha Configurations > Secrets.
Selecione kube-system na lista suspensa Namespace e verifique se addon.arms.token existe.

Se o token estiver ausente, conceda as permissões manualmente:

Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do cluster desejado. No painel de navegação à esquerda, clique em Cluster Information.
Na aba Basic Information, em Cluster Resources, clique no link ao lado de Worker RAM Role.
Na aba Permissions, clique em Grant Permission.
Selecione a política AliyunARMSFullAccess e clique em Grant permissions.

Se o cluster estiver conectado a uma Elastic Container Instance (ECI), acesse a página RAM Quick Authorization e conclua a autorização. Em seguida, reinicie os pods criados para o ack-onepilot.

Etapa 3: Integrar o agente Python do ARMS ao Dockerfile

Modifique o Dockerfile para integrar o agente Python do ARMS e usá-lo para iniciar a aplicação Python.

Instale o instalador do agente via PyPI:
```
   RUN pip3 install aliyun-bootstrap
```
Instale o agente. Substitua <region-id> pelo ID da região da Alibaba Cloud (por exemplo, cn-hangzhou):

Nota
Para instalar uma versão específica do agente, execute: aliyun-bootstrap -a install -v <version> Para consultar todas as versões lançadas, veja Python agent release notes.
```
   RUN ARMS_REGION_ID=<region-id> aliyun-bootstrap -a install
```
Atualize o comando de inicialização para usar o prefixo aliyun-instrument:
```
   CMD ["aliyun-instrument", "python", "app.py"]
```
Crie a imagem.

Veja abaixo um exemplo completo de Dockerfile:

Antes:

FROM docker.m.daocloud.io/python:3.10

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY ./app.py /app/app.py
EXPOSE 8000
CMD ["python", "app.py"]

Depois (com agente ARMS):

FROM docker.m.daocloud.io/python:3.10

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Install the ARMS Python agent
RUN pip3 install aliyun-bootstrap \
    && ARMS_REGION_ID=<region-id> aliyun-bootstrap -a install

COPY ./app.py /app/app.py
EXPOSE 8000

# Start the application with the ARMS agent
CMD ["aliyun-instrument", "python", "app.py"]

Etapa 4: Ativar o monitoramento do ARMS

Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do cluster. No painel de navegação à esquerda, clique em Workloads > Deployments.
Na página Deployments, localize a aplicação e clique em > Edit YAML na coluna Actions.

Adicione os seguintes rótulos em spec.template.metadata: Substitua <app-name> por um nome descritivo para a aplicação, como my-python-service.

Importante

Se você usar uma versão do ack-onepilot posterior à 5.0.0, mas já tiver instalado o agente manualmente no Dockerfile, desative a injeção automática adicionando este rótulo: ``yaml armsAutoInstrumentationEnable: "off" ``

   labels:
     aliyun.com/app-language: python       # Required. Identifies this as a Python application.
     armsPilotAutoEnable: 'on'             # Enables ARMS monitoring.
     armsPilotCreateAppName: "<app-name>"  # Display name in the ARMS console.

O código abaixo apresenta um modelo YAML completo para criar um Deployment e ativar o monitoramento da aplicação:

Exemplo completo de YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: arms-python-client
  name: arms-python-client
  namespace: arms-demo
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: arms-python-client
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: arms-python-client
        aliyun.com/app-language: python # Required. Specifies the application language as Python.
        armsPilotAutoEnable: 'on'
        armsPilotCreateAppName: "arms-python-client"    # The application's display name in the ARMS console.
    spec:
      containers:
        - image: registry.cn-hangzhou.aliyuncs.com/arms-default/python-agent:arms-python-client
          imagePullPolicy: Always
          name: client
          resources:
            requests:
              cpu: 250m
              memory: 300Mi
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: arms-python-server
  name: arms-python-server
  namespace: arms-demo
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: arms-python-server
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: arms-python-server
        aliyun.com/app-language: python # Required. Specifies the application language as Python.
        armsPilotAutoEnable: 'on'
        armsPilotCreateAppName: "arms-python-server"    # The application's display name in the ARMS console.
    spec:
      containers:
        - env:
          - name: CLIENT_URL
            value: 'http://arms-python-client-svc:8000'
          image: registry.cn-hangzhou.aliyuncs.com/arms-default/python-agent:arms-python-server
          imagePullPolicy: Always
          name: server
          resources:
            requests:
              cpu: 250m
              memory: 300Mi
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: arms-python-server
  name: arms-python-server-svc
  namespace: arms-demo
spec:
  internalTrafficPolicy: Cluster
  ipFamilies:
    - IPv4
  ipFamilyPolicy: SingleStack
  ports:
    - name: http
      port: 8000
      protocol: TCP
      targetPort: 8000
  selector:
    app: arms-python-server
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
kind: Service
metadata:
  name: arms-python-client-svc
  namespace: arms-demo
spec:
  internalTrafficPolicy: Cluster
  ipFamilies:
    - IPv4
  ipFamilyPolicy: SingleStack
  ports:
    - name: http
      port: 8000
      protocol: TCP
      targetPort: 8000
  selector:
    app: arms-python-client
  sessionAffinity: None
  type: ClusterIP

Etapa 5: Visualizar detalhes do monitoramento

Após cerca de um minuto, faça login no ARMS console. No painel de navegação à esquerda, escolha Application Monitoring > Applications para visualizar a aplicação Python e os dados reportados.

Na lista de aplicações, visualize a aplicação arms-python-client conectada e suas métricas, como requisições por segundo, taxa de erro e tempo médio de resposta.
Clique em Application Name para acessar a página de monitoramento da aplicação no console ARMS e visualizar informações detalhadas. Para mais informações, consulte Application overview.

(Opcional) Etapa 6: Liberar recursos

Se não for mais necessário monitorar a aplicação Python com o ARMS, desinstale o agente Python do ARMS para interromper o monitoramento. Para mais informações, consulte Uninstall the Python agent.