instalación en AWS EKS Fargate

New Relic admite el monitoreo de carga de trabajo Kubernetes en EKS Fargate al inyectar automáticamente un sidecar que contiene el agente de infraestructura y la integración nri-kubernetes en cada pod que necesita ser monitoreado.

Si el mismo clúster de Kubernetes también contiene nodos EC2, nuestra solución también será desplegar como DaemonSet en todos ellos. No se inyectará ningún sidecar en el módulo programado en los nodos EC2 y no se desplegará ningún DaemonSet en los nodos Fargate. A continuación se muestra un ejemplo de una instancia híbrida con nodos Fargate y EC2:

New Relic recopila todas las métricas admitidas para todos los objetos Kubernetes independientemente de dónde estén programados, ya sean nodos Fargate o EC2. Tenga en cuenta que, debido a las limitaciones impuestas por Fargate, la integración de New Relic se limita a ejecutarse en modo sin privilegios en los nodos de Fargate. Esto significa que las métricas que generalmente se obtienen directamente del host, como los procesos en ejecución, no estarán disponibles para los nodos Fargate.

El agente en ambos escenarios extraerá datos de Kube State métrica (KSM), Kubelet y cAdvisor y los enviará en el mismo formato.

Otros componentes de la solución New Relic para Kubernetes, como nri-prometheus, nri-metadata-injection y nri-kube-events, no tienen ninguna particularidad y se desplegarán mediante nuestro Helm Chart normalmente como lo harían en entornos que no son de Fargate.

Puede elegir entre dos alternativas para instalar la observabilidad total de New Relic en su clúster EKS Fargate:

• Inyección automática (recomendado)
• Inyección manual

Independientemente del enfoque que elija, la experiencia es exactamente la misma después de su instalación. La única diferencia es cómo se inyecta el contenedor. Recomendamos configurar la inyección automática con el operador de monitoreo de infraestructura New Relic porque eliminará la necesidad de editar manualmente cada despliegue que desee monitor.

Inyección automática (recomendado)

De forma predeterminada, cuando el soporte de Fargate está habilitado, New Relic desplegará un operador en el clúster (newrelic-infra-operator). Una vez implementado, este operador inyectará automáticamente el sidecar de monitoreo en los pods que están programados en los nodos de Fargate, mientras también administra la creación y actualización de Secrets, ClusterRoleBindings y cualquier otro recurso relacionado.

Este operador acepta una variedad de opciones de configuración avanzadas que se pueden usar para limitar o ampliar el alcance de la inyección, mediante el uso de selectores de etiquetas tanto para el pod como para el espacio de nombres.

Que hace el operador

Detrás de escena, el operador configura un MutatingWebhookConfiguration, que le permite modificar los objetos del pod que están a punto de crearse en el clúster. En este evento, y cuando el pod que se está creando coincida con la configuración del usuario, el operador:

1. Agregue un contenedor sidecar al pod que contiene la integración de New Relic Kubernetes.

2. Si no existe un secreto, cree uno en el mismo namespace que el pod que contiene la New Relic

   clave de licencia

   , que es necesaria para que el sidecar informe datos.

3. Agregue la cuenta de servicio del pod a un ClusterRoleBinding creado previamente por el gráfico del operador, lo que otorgará a este sidecar los permisos necesarios para alcanzar el extremo métrico Kubernetes .

El ClusterRoleBinding otorga los siguientes permisos al pod que se inyecta:

- apiGroups: [""]
  resources:
    - "nodes"
    - "nodes/metrics"
    - "nodes/stats"
    - "nodes/proxy"
    - "pods"
    - "services"
    - "namespaces"
  verbs: ["get", "list"]
- nonResourceURLs: ["/metrics"]
  verbs: ["get"]

Aquí está el flujo de trabajo de inyección:

$
helm repo add newrelic https://helm-charts.newrelic.com

## Global values

global:
# -- The cluster name for the Kubernetes cluster.
cluster: "_YOUR_K8S_CLUSTER_NAME_"

# -- The license key for your New Relic Account. This will be preferred configuration option if both `licenseKey` and `customSecret` are specified.
licenseKey: "_YOUR_NEW_RELIC_LICENSE_KEY_"

# -- (bool) In each integration it has different behavior. Enables operating system metric collection on each EC2 K8s node. Not applicable to Fargate nodes.
# @default -- false
privileged: true

# -- (bool) Must be set to `true` when deploying in an EKS Fargate environment
# @default -- false
fargate: true

## Enable nri-bundle sub-charts

newrelic-infra-operator:
# Deploys the infrastructure operator, which injects the monitoring sidecar into Fargate pods
enabled: true
tolerations: 
    - key: "eks.amazonaws.com/compute-type"
    operator: "Equal"
    value: "fargate"
    effect: "NoSchedule"
config:
    ignoreMutationErrors: true
    infraAgentInjection:
    # Injection policies can be defined here.  See [values file](https://github.com/newrelic/newrelic-infra-operator/blob/main/charts/newrelic-infra-operator/values.yaml#L114-L125) for more detail.
    policies:
    - namespaceName: namespace-a
    - namespaceName: namespace-b

newrelic-infrastructure:
# Deploys the Infrastructure Daemonset to EC2 nodes.  Disable for Fargate-only clusters.
enabled: true

nri-metadata-injection:
# Deploy our mutating admission webhook to link APM and Kubernetes entities
enabled: true

kube-state-metrics:
# Deploys Kube State Metrics.  Disable if you are already running KSM in your cluster.
enabled: true

nri-kube-events:
# Deploy the Kubernetes events integration.
enabled: true

newrelic-logging:
# Deploys the New Relic's Fluent Bit daemonset to EC2 nodes.  Disable for Fargate-only clusters.
enabled: true

newrelic-prometheus-agent:
# Deploys the Prometheus agent for scraping Prometheus endpoints.
enabled: true
config:
    kubernetes:
    integrations_filter:
        enabled: true
        source_labels: ["app.kubernetes.io/name", "app.newrelic.io/name", "k8s-app"]
        app_values: ["redis", "traefik", "calico", "nginx", "coredns", "kube-dns", "etcd", "cockroachdb", "velero", "harbor", "argocd", "istio"]

$
helm upgrade --install newrelic-bundle newrelic/nri-bundle -n newrelic --create-namespace -f values.yaml

Inyección automática: limitaciones conocidas

A continuación se detallan algunas cuestiones que debe tener en cuenta al utilizar la inyección automática:

1. Actualmente no existe ningún controlador que vigile todo el clúster para asegurarse de que los secretos que ya no son necesarios se recopilen como basura. Sin embargo, todos los objetos comparten la misma etiqueta que puedes usar para eliminar todos los recursos, si es necesario. Inyectamos la etiqueta newrelic/infra-operator-created: true, que puedes usar para eliminar recursos con un solo comando.
2. Por el momento, no es posible utilizar el sidecar inyectado para monitor los servicios que se ejecutan en el pod. El sidecar solo monitor el propio Kubernetes . Sin embargo, es posible que el usuario avanzado desee excluir estos pods de la inyección automática e inyectar manualmente una versión personalizada del sidecar con la integración en el host habilitada configurándolos y montando su configuración en el lugar adecuado. Para obtener ayuda, consulte este tutorial.

Inyección automática: configuración

Puedes configurar diferentes aspectos de la inyección automática. De forma predeterminada, el operador inyectará el sidecar de monitoreo en todos los pods desplegar en los nodos de Fargate que no formen parte de un Job o un BatchJob.

Este comportamiento se puede cambiar a través de las opciones de configuración. Por ejemplo, puede definir selectores para limitar o ampliar la selección de pods que se inyectan, asignar recursos al operador y ajustar el sidecar. Además, puedes agregar otros atributos, etiquetas y variables de entorno. Consulte el gráfico README.md y values.yaml.

Actualizar a la última versión o a una nueva configuración

Para actualizar a la última versión de la integración EKS Fargate, actualice el repositorio Helm usando helm repo update newrelic y reinstale el paquete simplemente ejecutando nuevamente el comando anterior.

Para actualizar la configuración del agente de infraestructura inyectado o del propio operador, modifique values-newrelic.yaml y actualice la versión de Helm con la nueva configuración. El operador se actualiza inmediatamente y su carga de trabajo quedará instrumentada con la nueva versión en su próximo reinicio. Si deseas actualizarlos inmediatamente, puedes forzar un reinicio de tu carga de trabajo ejecutando:

$
kubectl rollout restart deployment YOUR_APP

Inyección automática: Desinstalar

Para desinstalar el sidecar que realiza la inyección automática pero conservar el resto de la solución New Relic, usando Helm, desactive el infraoperador configurando infra-operator.enabled en false, ya sea en el archivo values.yaml o en la línea de comando (--set) y vuelva a ejecutar el comando de instalación anterior.

Recomendamos encarecidamente mantener el indicador --set global.fargate=true , ya que no habilita la inyección automática pero hace que otros componentes de la instalación sean compatibles con Fargate, evitando comportamientos no deseados.

Para desinstalar toda la solución:

1. Desinstale completamente la versión Helm.

2. Despliegue la cápsula para quitar el sidecar:

   bash

   Copia

   $
   kubectl rollout restart deployment YOUR_APP

3. Basura recoge los secretos:

   bash

   Copia

   $
   kubectl delete secrets -n YOUR_NAMESPACE -l newrelic/infra-operator-created=true

Inyección manual

Si tiene alguna inquietud sobre la inyección automática, puede inyectar el sidecar manualmente directamente modificando los manifiestos de la carga de trabajo programada que se programarán en los nodos de Fargate. Tenga en cuenta que agregar el sidecar al despliegue programado en los nodos EC2 puede generar datos incorrectos o duplicados, especialmente si esos nodos ya se están monitoreando con DaemonSet.

Estos objetos son necesarios para que el sidecar informe datos correctamente:

• El ClusterRole proporciona la licencia necesaria para la integración nri-kubernetes .
• Un ClusterRoleBinding que vincula el ClusterRole y la cuenta de servicio del pod.
• El secreto que almacena la New Relic licenseKey en cada namespace de Fargate.
• El contenedor sidecar en la plantilla específica del monitor carga de trabajo.

Complete estos pasos para la inyección manual:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
    labels:
    app: newrelic-infrastructure
    name: newrelic-newrelic-infrastructure-infra-agent
rules:
    - apiGroups:
        - ""
    resources:
        - nodes
        - nodes/metrics
        - nodes/stats
        - nodes/proxy
        - pods
        - services
    verbs:
        - get
        - list
    - nonResourceURLs:
        - /metrics
    verbs:
        - get

apiVersion: apps/v1
kind: Deployment
spec:
    template:
    spec:
        containers:
        - name: newrelic-infrastructure
        env:
        - name: NRIA_LICENSE_KEY
            valueFrom:
            secretKeyRef:
                key: license
                name: newrelic-newrelic-infrastructure-config
        - name: NRIA_VERBOSE
            value: "1"
        - name: DISABLE_KUBE_STATE_METRICS
            value: "true"
        - name: CLUSTER_NAME
            value: testing-injection
        - name: COMPUTE_TYPE
            value: serverless
        - name: NRK8S_NODE_NAME
            valueFrom:
            fieldRef:
                apiVersion: v1
                fieldPath: spec.nodeName
        - name: NRIA_DISPLAY_NAME
            valueFrom:
            fieldRef:
                apiVersion: v1
                fieldPath: spec.nodeName
        - name: NRIA_CUSTOM_ATTRIBUTES
            value: '{"clusterName":"$(CLUSTER_NAME)", "computeType":"$(COMPUTE_TYPE)", "fargateProfile":"[YOUR FARGATE PROFILE]"}'
        - name: NRIA_PASSTHROUGH_ENVIRONMENT
            value: KUBERNETES_SERVICE_HOST,KUBERNETES_SERVICE_PORT,CLUSTER_NAME,CADVISOR_PORT,NRK8S_NODE_NAME,KUBE_STATE_METRICS_URL,KUBE_STATE_METRICS_POD_LABEL,TIMEOUT,ETCD_TLS_SECRET_NAME,ETCD_TLS_SECRET_NAMESPACE,API_SERVER_SECURE_PORT,KUBE_STATE_METRICS_SCHEME,KUBE_STATE_METRICS_PORT,SCHEDULER_ENDPOINT_URL,ETCD_ENDPOINT_URL,CONTROLLER_MANAGER_ENDPOINT_URL,API_SERVER_ENDPOINT_URL,DISABLE_KUBE_STATE_METRICS,DISCOVERY_CACHE_TTL
        image: newrelic/infrastructure-k8s:2.4.0-unprivileged
        imagePullPolicy: IfNotPresent
        resources:
            limits:
            memory: 100M
            cpu: 200m
            requests:
            cpu: 100m
            memory: 50M
        securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            runAsUser: 1000
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /var/db/newrelic-infra/data
            name: tmpfs-data
        - mountPath: /var/db/newrelic-infra/user_data
            name: tmpfs-user-data
        - mountPath: /tmp
            name: tmpfs-tmp
        - mountPath: /var/cache/nr-kubernetes
            name: tmpfs-cache
[...]

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
    name: newrelic-newrelic-infrastructure-infra-agent
roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: newrelic-newrelic-infrastructure-infra-agent
subjects:
    - kind: ServiceAccount
    name: [INSERT_SERVICE_ACCOUNT_NAME_OF_WORKLOAD]
    namespace: [INSERT_SERVICE_ACCOUNT_NAMESPACE_OF_WORKLOAD]

apiVersion: v1
data:
    license: INSERT_YOUR_NEW_RELIC_LICENSE_ENCODED_IN_BASE64
kind: Secret
metadata:
    name: newrelic-newrelic-infrastructure-config
    namespace: [INSERT_NAMESPACE_OF_WORKLOAD]
type: Opaque

Inyección manual: Actualización a la última versión

Para actualizar cualquiera de los componentes, solo necesitas modificar desplegar yaml. La actualización de cualquiera de los campos del contenedor inyectado hará que se vuelva a crear el pod.

Inyección manual: Desinstalar la integración Fargate

Para eliminar el contenedor inyectado y los recursos relacionados, sólo tienes que eliminar lo siguiente:

• El sidecar de la carga de trabajo que ya no debería ser monitoreado.
• Todos los secretos que contiene la licencia newrelic.
• ClusterRole y ClusterRoleBinding objetos.

Tenga en cuenta que eliminar el contenedor sidecar hará que se vuelva a crear el pod .

Logging

El registro de New Relic no está disponible en los nodos de Fargate debido a restricciones de seguridad impuestas por AWS, pero aquí hay algunas opciones de registro:

• Si estás utilizando Fluentbit para iniciar sesión, consulta el complementoKubernetes para reenvío de registros.
• Si FireLens log ya supervisa sus datos AWS , consulte AWS el complemento FireLens para obtener información sobre el reenvío de registros .
• Si sus datos log ya están siendo monitoreados por el registro de Amazon CloudWatch, consulte Transmitir registro mediante Kinesis Data Firehose.
• Consulte AWS Lambda para enviar registros de CloudWatch.
• Consulte Tres formas de reenviar registros de Amazon ECS a New Relic.

Resolución de problemas

LAST SEEN | TYPE | REASON | OBJECT | MESSAGE
:--|:--|:--|:--|:--
3m9s (x2 over 8m10s) | Warning | FailedScheduling | Pod/no-fargate-deploy-cbddd6ccf-8f9x4 | 0/2 nodes are available: 2 node(s) had untolerated taint {eks.amazonaws.com/compute-type: fargate}. preemption: 0/2 nodes are available: 2 Preemption is not helpful for scheduling..

LAST SEEN | TYPE | REASON | OBJECT | MESSAGE
:--|:--|:--|:--|:--
61s | Warning | FailedScheduling | Pod/newrelic-bundle-newrelic-infra-operator-admission-create-d8ggt | 0/2 nodes are available: 2 Too many pods. preemption: 0/2 nodes are available: 2 No preemption victims found for incoming pod..

Ver sus datos EKS

A continuación se muestra un ejemplo de cómo se ve un nodo Fargate en la New Relic UI:

Para ver sus datos de AWS:

1. Vaya a one.newrelic.com > All capabilities > Infrastructure > Kubernetes y realice una de las siguientes acciones:

   • Seleccione un nombre de integración para ver los datos.
   • Seleccione el icono Explorar datos para ver los datos de AWS.

2. Filtra tus datos usando dos etiquetas Fargate:

   • computeType=serverless
   • fargateProfile=[name of the Fargate profile to which the workload belongs]