7 Journalisation

Vous pouvez utiliser Oracle Cloud Infrastructure (OCI) ou des outils externes pour configurer la journalisation persistante pour Oracle Blockchain Platform Enterprise Edition.

Aperçu

Enterprise Edition pour Oracle Blockchain Platform est basé sur Kubernetes, où les journaux sont stockés localement sur chaque module de réseautage. Pour empêcher la suppression des journaux lorsqu'un pod est supprimé, vous devez configurer une journalisation persistante, où les journaux sont stockés dans un emplacement central. Vous pouvez utiliser deux méthodes pour la journalisation persistante. Vous pouvez utiliser un outil de journalisation externe tel que Fluentd et Elastic Stack. Sinon, si vous utilisez Oracle Kubernetes Engine, vous pouvez utiliser la solution de journalisation centralisée prise en charge par Oracle Cloud Infrastructure (OCI).

Journalisation persistante avec OCI

Pour stocker les journaux de manière centralisée à l'aide d'OCI, vous définissez des groupes de journaux et configurez des agents pour analyser les journaux. Les journaux sont stockés dans le service de stockage d'objets. Avant de configurer la journalisation persistante avec OCI, votre déploiement doit répondre aux exigences suivantes.
  • Groupe dynamique dans le compartiment Kubernetes. Pour créer un groupe dynamique, cliquez sur Identité et sécurité dans le menu de navigation. Sous Identité, cliquez sur Domaines, puis sur Créer un groupe dynamique. Ajoutez ce qui suit à votre groupe dynamique dans la section Règles de correspondance, en remplaçant l'ID Oracle Cloud par votre compartiment.
    instance.compartment.id = '<compartment_ocid>'
    Par exemple :
    instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa4ws3242343243244nyb423432rwqsxigt2sia'
  • Politique qui permet au groupe dynamique d'interagir avec le service de journalisation. Pour créer une politique, cliquez sur Identité et sécurité dans le menu de navigation. Sous Identité, cliquez sur Politiques, puis sur Créer une politique.
    Allow dynamic-group <my-group> to use log-content in compartment <target_compartment_name>
    Par exemple :
    Allow dynamic-group okelogging to use log-content in compartment BlockchainTeam
Après avoir satisfait aux préalables, effectuez les étapes suivantes pour stocker les journaux de manière centralisée à l'aide d'OCI.
  1. Cliquez sur l'icône de menu dans le coin supérieur gauche, recherchez journal, puis sélectionnez Journaux.
  2. Créer un groupe de journaux. Sous Journalisation, sélectionnez Groupes de journaux, puis cliquez sur Créer un groupe de journaux.
  3. Créez un journal personnalisé. Sous Journalisation, sélectionnez Journaux, puis cliquez sur Créer un journal personnalisé pour ouvrir l'assistant Créer un journal personnalisé. Sélectionnez le groupe de journaux que vous avez créé précédemment.
  4. Dans la deuxième page de l'assistant Créer un journal personnalisé, créez une configuration d'agent pour le journal personnalisé, en spécifiant le compartiment Kubernetes et le groupe dynamique.
  5. Dans la section Configurer les entrées de journal de la page Configuration de l'agent, configurez l'entrée de journal pour que l'agent utilise le chemin d'accès au fichier suivant, qui est la valeur par défaut pour les conteneurs d'application. Sélectionnez Chemin du fichier journal dans la liste Type d'entrée. Entrez le chemin d'accès suivant pour les chemins d'accès. Ce chemin inclut tous les journaux de conteneur, y compris les conteneurs système et de service.
    /var/log/pods/*/*/*.log
  6. Attendez que les journaux soient ingérés. En général, les journaux sont ingérés en 3 à 5 minutes.
  7. Sélectionnez Journaux, puis naviguez jusqu'au journal personnalisé et cliquez sur Explorer le journal. Vous pouvez analyser, analyser et filtrer les journaux.
  8. Vous pouvez également utiliser OCI pour stocker les journaux dans le service de stockage d'objets.
    1. Créez un connecteur. Sous Journalisation, sélectionnez Connecteurs, puis cliquez sur Créer un connecteur. Sélectionnez Journalisation comme Source et Stockage d'objets comme cible.
    2. Configurez la source et la cible selon les besoins.
    3. Sous la section Activer les journaux, réglez Activer le journal à Activé pour le connecteur que vous avez créé. Le panneau Créer un journal s'affiche, avec une valeur par défaut pour le temps de conservation des journaux.
    4. Attendez que les journaux soient ingérés. En général, les journaux sont ingérés en 3 à 5 minutes. Vous pouvez ensuite voir les opérations de lecture et d'écriture dans les journaux du connecteur. Les journaux sont en cours d'écriture dans le service de stockage d'objets.

Pour plus d'informations, voir Surveiller les grappes Kubernetes et OKE avec OCI Logging Analytics.

Journalisation persistante avec des outils externes

Vous pouvez stocker les journaux de manière centralisée à l'aide de Fluentd et d'Elastic Stack. Les étapes suivantes ont été testées avec Fluentd v1.16.2 et Elasticsearch 7.9.1. Utilisez ces versions ou des versions ultérieures lorsque vous effectuez ces étapes.
  1. Créez un espace de noms Kubernetes nommé fluentd.
  2. Utilisez la commande suivante pour créer une ressource de contrôle d'accès basée sur des rôles.
    kubectl create -f fluentd-rbac.yaml -n fluentd
    Utilisez le fichier fluentd-rbac.yaml suivant avec la commande.
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: fluentd
      namespace: fluentd
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      name: fluentd
      namespace: fluentd
    rules:
    - apiGroups:
      - ""
      resources:
      - pods
      - namespaces
      verbs:
      - get
      - list
      - watch
    ---
    kind: ClusterRoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: fluentd
    roleRef:
      kind: ClusterRole
      name: fluentd
      apiGroup: rbac.authorization.k8s.io
    subjects:
    - kind: ServiceAccount
      name: fluentd
      namespace: fluentd
  3. Utilisez la commande suivante pour créer un objet ConfigMap pour Fluentd ou Elastic Stack.
    kubectl create -f fluentd-configmap_removefilter_ascii.yaml -n fluentd
    Utilisez le fichier fluentd-configmap_removefilter_ascii.yaml suivant avec la commande.
    Dans le fichier suivant, supprimez le signe numérique (#) pour annuler la mise en commentaire d'une seule des lignes suivantes.
    • Décommentez @include file-fluent.conf si vous écrivez dans un fichier dans le chemin /tmp/obp.log.
    • Décommentez @include elastic-fluent.conf si vous écrivez à Elasticsearch.
    Le fichier suivant présente un exemple d'écriture dans le chemin /tmp/obp.log.
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fluentd-config
      namespace: fluentd
    data:
      fluent.conf: |-
        ################################################################
        # This source gets all logs from local docker host
        #@include pods-kind-fluent.conf
        #@include pods-fluent.conf
        @include pods-nofilter.conf
        @include file-fluent.conf
        #@include elastic-fluent.conf
      pods-nofilter.conf: |-
        <source>
          @type tail
          path /var/log/containers/*.log
          format //^(?<time>.+) (?<stream>stdout|stderr) (?<logtag>.)? (?<log>.*)$/ /
          pos_file /var/log/fluentd-containers.log.pos
          tag kubernetes.*
          read_from_head true
        </source>
        <filter kubernetes.**>
         @type kubernetes_metadata
        </filter>
      file-fluent.conf: |-
         <match kubernetes.var.log.containers.**fluentd**.log>
          @type null
         </match>
         <match kubernetes.var.log.containers.**kube-system**.log>
           @type null
         </match>
         <match kubernetes.**>
           @type file
           path /tmp/obp.log
         </match>
      elastic-fluent.conf: |-
        <match kubernetes.var.log.containers.**fluentd**.log>
          @type null
        </match>
        <match kubernetes.var.log.containers.**kube-system**.log>
          @type null
        </match>
        <match kubernetes.**>
          @type elasticsearch
          host "#{ENV['FLUENT_ELASTICSEARCH_HOST'] || 'elasticsearch.elastic-kibana'}"
          port "#{ENV['FLUENT_ELASTICSEARCH_PORT'] || '9200'}"
          index_name fluentd-k8s-3
          type_name fluentd
          include_timestamp true
        </match>
  4. Utilisez la commande suivante pour créer un objet DaemonSet pour Fluentd. Cette commande crée un pod Fluentd sur chaque noeud.
    kubectl create -f fluentd.yaml -n fluentd
    Utilisez le fichier fluentd.yaml suivant avec la commande.
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: fluentd
      namespace: fluentd
      labels:
        k8s-app: fluentd-logging
        version: v1
    spec:
      selector:
        matchLabels:
          k8s-app: fluentd-logging
          version: v1
      template:
        metadata:
          labels:
            k8s-app: fluentd-logging
            version: v1
        spec:
          serviceAccount: fluentd
          serviceAccountName: fluentd
          tolerations:
          - key: node-role.kubernetes.io/master
            effect: NoSchedule
          - key: node-role.kubernetes.io/control-plane
            effect: NoSchedule 
          containers:
          - name: fluentd1
            imagePullPolicy: "Always"
            image: fluent/fluentd-kubernetes-daemonset:v1.16.2-debian-elasticsearch7-1.1
            env:
              - name:  FLUENT_ELASTICSEARCH_HOST
                value: "elasticsearch.elastic-kibana"
              - name:  FLUENT_ELASTICSEARCH_PORT
                value: "9200"
            resources:
              limits:
                memory: 200Mi
              requests:
                cpu: 100m
                memory: 200Mi
            volumeMounts:
            - name: fluentd-config
              mountPath: /fluentd/etc
            - name: logs
              mountPath: /tmp
            - name: varlog
              mountPath: /var/log
            - name: varlibdockercontainers
              mountPath: /var/lib/docker/containers
              readOnly: true
          terminationGracePeriodSeconds: 30
          volumes:
          - name: fluentd-config
            configMap:
              name: fluentd-config
          - name: varlog
            hostPath:
              path: /var/log
          - name: varlibdockercontainers
            hostPath:
              path: /var/lib/docker/containers
          - name: logs
            hostPath:
              path: /tmp
    Les journaux Oracle Blockchain Platform sont disponibles dans le répertoire /tmp du module de réseautage Fluentd ou du noeud Kubernetes.
  5. Pour envoyer les journaux à la pile élastique, créez un espace de noms Kubernetes nommé elastic-kibana.
  6. Utilisez la commande suivante pour créer un déploiement pour Elastic Stack et l'exposer en tant que service.
    kubectl create -f elastic.yaml -n elastic-kibana
    Utilisez le fichier elastic.yaml suivant avec la commande.
    apiVersion: v1
    kind: Namespace
    metadata:
      name: elastic-kibana
    
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: elasticsearch
      namespace: elastic-kibana
      labels:
        app: elasticsearch
    spec:
      selector:
        matchLabels:
          app: elasticsearch
      replicas: 1
      template:
        metadata:
          labels:
            app: elasticsearch
        spec:
          initContainers:
          - name: vm-max-fix
            image: busybox
            command: ["sysctl", "-w", "vm.max_map_count=262144"]
            securityContext:
              privileged: true
          containers:
          - name: elasticsearch
            image: elasticsearch:7.9.1
            imagePullPolicy: IfNotPresent
            ports:
            - containerPort: 9200
            env:
            - name: node.name
              value: "elasticsearch"
            - name: cluster.initial_master_nodes
              value: "elasticsearch"
            - name: bootstrap.memory_lock
              value: "false"
            - name: ES_JAVA_OPTS
              value: "-Xms512m -Xmx512m"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: elasticsearch
      namespace: elastic-kibana
      labels:
        app: elasticsearch
    spec:
      type: ClusterIP
      selector:
        app: elasticsearch
      ports:
        - protocol: TCP
          name: http
          port: 9200
          targetPort: 9200
  7. Vous pouvez ensuite utiliser les commandes suivantes pour examiner les données de journal dans l'index Elasticsearch.
    curl -X GET "localhost:9200/_cat/indices/fluentd-k8s-*?v=true&s=index&pretty"
    curl -X GET "localhost:9200/fluentd-k8s-3/_search?pretty=true"
  8. Vous pouvez également utiliser Fluentd pour stocker le journal sur le volume par blocs local sur chaque noeud.
    1. Créez un volume par blocs pour chaque noeud, attachez le volume et créez un répertoire nommé /u01.
    2. Formatez le volume par blocs attaché pour le système de fichiers ext4.
    3. Montez le répertoire /u01 sur le chemin de périphérique.
    4. Modifiez le fichier de déploiement Fluentd (fluentd.yaml) de sorte que le volume des journaux soit /u01, et non /tmp, comme indiqué dans l'extrait de code suivant.
      - name: logs
              hostPath:
                path: /u01
    5. Exécutez la commande suivante pour appliquer le déploiement Fluentd.
      kubectl apply -f fluentd.yaml -n fluentd
    6. Les journaux sont maintenant visibles dans le répertoire /u01 sur chaque noeud.

Définir le niveau de journal pour les pods d'opérateur

Vous pouvez définir le niveau de journal pour les pods hlf-operator et obp-operator. Les étapes de définition du niveau de journal diffèrent selon qu'Oracle Blockchain Platform est installé. Si Oracle Blockchain Platform Enterprise Edition n'est pas encore installé, procédez comme suit.

  1. Ouvrez le fichier deployment.yaml correspondant pour le modifier. Le fichier du pod hlf-operator se trouve à l'emplacement suivant :
    distribution_package_location/distribution-package/operators/helmcharts/hlf-operator/templates/deployment.yaml
    Le fichier du pod obp-operator se trouve à l'emplacement suivant :
    distribution_package_location/distribution-package/operators/helmcharts/obp-operator/templates/deployment.yaml
  2. Ajoutez la ligne suivante au fichier. Comme indiqué dans le commentaire, vous pouvez régler le niveau de journal à debug, info ou error. Dans l'exemple suivant, le niveau de journalisation est réglé à info.
    --zap-log-level=info # debug, info, error
Après avoir modifié le fichier, cette section du fichier peut ressembler au texte suivant :
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error

Si Oracle Blockchain Platform est déjà installé, effectuez l'étape suivante.

  • Utilisez les commandes suivantes pour modifier les définitions de déploiement des pods hlf-operator et obp-operator. Ajoutez ou mettez à jour l'argument qui configure le niveau de journal pour le conteneur manager sous la spécification du modèle de pod.
    kubectl edit deployment -n obp-cp obp-operator
    kubectl edit deployment -n obp-cp hlf-operator-controller-manager
Après avoir mis à jour les arguments du conteneur, la définition du déploiement peut ressembler au texte suivant :
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error