Installation de l'agent sur Red Hat OpenShift

Avant d'installer l'agent, assurez-vous que les conditions préalables sont remplies.

Vous pouvez installer l'agent d' Instana ation sur un cluster Red Hat OpenShift en utilisant les méthodes suivantes :

• Instana opérateur
• Helm graphique (en ligne)
• Helm diagramme (en environnement isolé)

Pour installer l'agent sur Red Hat OpenShift sur la plateforme IBM Z ou LinuxONE, utilisez le graphique disponible à l'adresse Helm (en ligne).

Pour installer l'agent d' Instana ation sur Red Hat OpenShift à l'aide de l'opérateur, procédez comme suit :

1. Complétez les étapes préalables avant de procéder à l'installation de l'opérateur.

2. Installez l'opérateur en utilisant l'une des méthodes suivantes :

   • Installez l'opérateur en utilisant Operator Lifecycle Manager (OLM) (de préférence pour Red Hat OpenShift).

   • Installez l'opérateur manuellement.

Vous pouvez utiliser le tableau Helm pour installer l'agent. Le tableau « Helm » ajoute l'agent « Instana » à tous les nœuds pouvant être planifiés dans votre cluster à l'aide d'un « DaemonSet ».

Pour installer l'agent « Instana » à l'aide de l'image « Helm », vous devez d'abord installer ou mettre à niveau vers la version 3 d' Helm.

Le graphique de l'agent Instana Helm prend en charge Red Hat OpenShift 4.x.

Pour installer l'agent Instana sur Red Hat OpenShift à l'aide du tableau Helm, procédez comme suit :

1. Sur la page d'accueil de l'interface utilisateur d' Instana, cliquez sur « Agents et collecteurs ». Dans l'onglet « Agents » de l' Instana, sélectionnez « Installer les agents ».

2. Sur la page du catalogue de déploiement de l'agent, cliquez sur la tuile OpenShift - Helm chart.

3. Saisissez le nom du cluster et (facultativement) la zone d'agents dont vous voulez que le cluster fasse partie.

   Le nom du cluster (<your_cluster_name>) est le nom personnalisé du cluster surveillé par ce DaemonSet.

   La zone d'agent (<your_zone_name>) permet de personnaliser le regroupement des zones affiché sur la carte de l'infrastructure.

   Le code de déploiement de l'agent est mis à jour avec les valeurs que vous avez fournies. Tous les autres paramètres requis sont pré-remplis dans le code de déploiement de l'agent, qui ressemble à l'exemple suivant :

   INSTANA_AGENT_NAMESPACE=instana-agent
   oc login -u system:admin
   oc new-project ${INSTANA_AGENT_NAMESPACE}
   oc adm policy add-scc-to-user privileged -z instana-agent -n "${INSTANA_AGENT_NAMESPACE}"
   oc adm policy add-scc-to-user anyuid -z instana-agent-remote -n "${INSTANA_AGENT_NAMESPACE}"
   helm install instana-agent \
   --repo https://agents.instana.io/helm \
   --namespace ${INSTANA_AGENT_NAMESPACE} \
   --set agent.key='<your_agent_key>' \
   --set agent.endpointHost='<your_host_agent_endpoint>' \
   --set agent.endpointPort=443 \
   --set cluster.name='<your_cluster_name>' \
   --set zone.name='<your_zone_name>' \
   instana-agent

4. Lorsque vous installez l'agent Instana sur IBM Z ou LinuxONE,, configurez des zones distinctes au cours du processus d'installation. Cette distinction est importante car l'agent d' Instana, tout comme les charges de travail des applications qu'il surveille, se trouvent au sein du même cluster.

   Contrairement à d'autres environnements où l' Instana e et les applications surveillées sont déployées séparément, les configurations de type IBM Z ou LinuxONE partagent le même cluster. Cela rend indispensable la mise en place de zones d'isolement. Pour isoler les zones, assurez-vous que les nœuds sur lesquels « Instana » est installé sont correctement étiquetés et marqués.

   Si l'étiquette utilisée est node-role.kubernetes.io/monitor=true. Pour vérifier que les nœuds de l' Instana t correctement identifiés, exécutez la commande suivante :

   kubectl get nodes -l node-role.kubernetes.io/monitor=true

   Pour vérifier que les nœuds de l' Instana sont bien marqués comme prévu avec l'étiquette d'exemple node.instana.io/monitor=true, exécutez la commande suivante :

   kubectl get nodes -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{range .spec.taints[*]}{.key}{"="}{.value}{"\t"}{end}{"\n"}{end}' | grep 'node\.instana\.io/monitor'

   Après avoir vérifié que les nœuds d' Instana s sont étiquetés et marqués, vous pouvez suivre les étapes suivantes :

   1. Étiqueter les nœuds exécutant des charges de travail d'application : assurez-vous que les nœuds exécutant des charges de travail d'application sont correctement étiquetés afin de les distinguer des nœuds d'infrastructure.

      NODE=<your node name>
      CLUSTER=<your cluster name>
      oc label node worker${NODE}.${CLUSTER_NAME} workload="true"

   2. Définir deux zones

      • Configurez les nœuds « Instana » sur le INFRASTRUCTURE mode.
      • Configurez les nœuds de charge de travail de l'application en mode APM .
      • Créez un fichier « YAMLagent_values.yaml » et indiquez-y les zones ainsi que leurs affinités et leurs tolérances.

      zones:
        - name: workloads
          mode: APM
          affinity:
             nodeAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                  - matchExpressions:
                      - key: workload
                        operator: Exists
        - name: instana-nodes
          mode: INFRASTRUCTURE
          tolerations:
            - key: node.instana.io/monitor
              operator: Equal
              effect: NoSchedule
              value: "true"
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                  - matchExpressions:
                      - key: node-role.kubernetes.io/monitor
                        operator: In
                        values:
                          - "true"

      Dans cet exemple de fichier ` YAML `, on part du principe que les nœuds de l' Instana sont étiquetés avec node-role.kubernetes.io/monitor=true et marqués avec la clé : node.instana.io/monitor=true. Mettez ces valeurs à jour en fonction de vos propres conventions d'étiquetage et de marquage des nœuds.

      Ajoutez votre fichier YAML personnalisé à la fin du code de déploiement de l'agent, comme indiqué dans l'exemple suivant :

      INSTANA_AGENT_NAMESPACE=instana-agent
      oc login -u system:admin
      oc new-project ${INSTANA_AGENT_NAMESPACE}
      oc adm policy add-scc-to-user privileged -z instana-agent -n "${INSTANA_AGENT_NAMESPACE}"
      oc adm policy add-scc-to-user anyuid -z instana-agent-remote -n "${INSTANA_AGENT_NAMESPACE}"
      helm install instana-agent \
      --repo https://agents.instana.io/helm \
      --namespace ${INSTANA_AGENT_NAMESPACE} \
      --set agent.key='<your_agent_key>' \
      --set agent.endpointHost='<your_host_agent_endpoint>' \
      --set agent.endpointPort=443 \
      --set cluster.name='<your_cluster_name>' \
      --set zone.name='<your_zone_name>' \
      instana-agent -f agent_values.yaml

5. Modifiez le code de déploiement de l'agent.

   • Pour configurer l'installation, vous pouvez spécifier les valeurs sur la ligne de commande à l'aide du --set drapeau ou fournir un fichier de YAML s contenant vos valeurs à l'aide du -f drapeau. Pour obtenir la liste détaillée de tous les paramètres de configuration et des exemples, consultez le tableau disponible à l'adresse InstanaHelm. Consultez également les rubriques suivantes :

     • Configuration de backends supplémentaires
     • Configuration d'un proxy entre les agents Instana et le serveur Instana
     • Définition de volumes d' Kubernetes s personnalisés et d' volumeMounts

   • Facultatif : Pour déployer l'agent statique, activez le drapeau " --set agent.image.name=containers.instana.io/instana/release/agent/static.

   • Le service Kubernetes créé par défaut expose les éléments suivants au cluster :

     • OpenTelemetry Point de terminaison pour otlp l'ingestion via gRPC
     • la mise en œuvre de Prometheus« remote_write API
     • SDK Web Trace
     • autres API d'agent.

   • Facultatif : si vous souhaitez activer le chiffrement « TLS » pour le point de terminaison de l'agent, utilisez un secret existant ou un certificat et une clé privée :

     • Utilisation d'un secret existant de type kubernetes.io/tls

       Vous pouvez utiliser un secret existant de ce type kubernetes.io/tls pour le chiffrement « TLS ». Mais vous devez spécifier le 'secretName avec le '--set 'agent.tls.secretName=<YOUR_SECRET_NAME>' pendant l'installation. Les fichiers du secret fourni sont alors inclus dans l'agent.

     • Utiliser un certificat et une clé privée

       Le certificat et la clé privée doivent être base64-encoded. Pour utiliser cette variante, exécutez la commande ` helm ` avec les paramètres supplémentaires suivants :

       --set 'agent.tls.certificate=<YOUR_CERTIFICATE_BASE64_ENCODED>'
       --set 'agent.tls.key=<YOUR_PRIVATE_KEY_BASE64_ENCODED>'

       Remarque : si l'option « agent.tls.secretName » est activée, les options « agent.tls.certificate » et « agent.tls.key » sont ignorées.

6. Copiez et exécutez le code de déploiement de l'agent.

L'agent est maintenant installé. Pour savoir ce que vous pouvez faire après l'installation, consultez la section Que faire ensuite ?

Pour mettre à jour l'agent, voir Mise à jour de l'installation d'un opérateur.

Red Hat OpenShift fournit un registre de conteneurs interne que vous pouvez utiliser dans des environnements isolés physiquement pour stocker des images permettant d'exécuter des charges de travail au sein du cluster.

Assurez-vous d'installer les logiciels suivants avant d'installer l'agent :

• Interface de ligne de commande OpenShift (oc)
• jq
• Skopeo

Pour installer l'agent d' Instana ation à l'aide d'un tableau de configuration « Helm » dans un environnement isolé, procédez comme suit :

1. Connectez-vous au cluster « Red Hat OpenShift » en tant qu'administrateur en exécutant la commande suivante :

   oc login --server=https://api.myopenshiftcluster.com:6443 -u kubeadmin -p $OPENSHIFT_PASSWORD

2. Rendez le registre de conteneurs interne accessible depuis votre hôte de saut :

   oc patch configs.imageregistry.operator.openshift.io/cluster --type merge -p '{"spec":{"defaultRoute":true}}'

3. Récupérer le nom d'hôte utilisé pour accéder au registre depuis l'extérieur :

   HOST=$(oc get route default-route -n openshift-image-registry --template='{{ .spec.host }}')

4. Créez un projet « instana » (s'il n'a pas déjà été créé) dans le cluster Red Hat OpenShift, afin de permettre le transfert d'images vers l'espace de noms spécifié :

   oc get project instana || oc new-project instana

5. Afficher les informations relatives à l'hôte du registre :

   echo "${HOST}" # default-route-openshift-image-registry.apps.myopenshiftcluster.com

6. Récupérez le certificat de l'opérateur d'Ingress de confiance et ajoutez-le dans le répertoire de l'autorité de certification (CA) du système :

   oc extract secret/$(oc get ingresscontroller -n openshift-ingress-operator default -o json | jq '.spec.defaultCertificate.name // "router-certs-default"' -r) -n openshift-ingress --confirm

   Si cette étape n'est pas respectée, des avertissements relatifs au certificat (par exemple, tls: failed to verify certificate: x509: certificate signed by unknown authority) peuvent s'afficher lorsque vous essayez de pousser l'image vers le registre cible.

7. Importez l'autorité de certification dans le magasin des autorités de certification de confiance du système à l'aide des commandes suivantes :

   sudo mv tls.crt /etc/pki/ca-trust/source/anchors/
   sudo update-ca-trust

8. Connectez-vous aux registres source et de destination à l'aide de l'adresse Skopeo :

   skopeo login -u kubeadmin -p $(oc whoami -t) $HOST
   skopeo login -u _ -p $AGENT_DOWNLOAD_KEY containers.instana.io

9. Déterminez les dernières versions disponibles pour chaque composant :

   LATEST_OPERATOR_VERSION=$(skopeo inspect docker://icr.io/instana/instana-agent-operator:latest | jq -r ".Labels.version")
   LATEST_AGENT_VERSION=$(skopeo inspect docker://containers.instana.io/instana/release/agent/static:latest | jq -r ".Labels.version")
   LATEST_K8S_SENSOR_VERSION=$(skopeo inspect docker://icr.io/instana/k8sensor:latest | jq -r '.Labels["com.instana.commit.id"]')

10. Copiez les composants requis dans le registre local :

    skopeo copy docker://icr.io/instana/instana-agent-operator:latest "docker://${HOST}/instana/instana-agent-operator:${LATEST_OPERATOR_VERSION}"
    skopeo copy docker://containers.instana.io/instana/release/agent/static:latest "docker://${HOST}/instana/instana-agent-static:${LATEST_AGENT_VERSION}"
    skopeo copy docker://icr.io/instana/k8sensor:latest "docker://${HOST}/instana/k8sensor:${LATEST_K8S_SENSOR_VERSION}"