7 Journalisation

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

Présentation

Oracle Blockchain Platform Enterprise Edition est basé sur Kubernetes, où les journaux sont stockés localement sur chaque pod. Pour empêcher la suppression des journaux lorsqu'un pod est supprimé, vous devez configurer la journalisation persistante, dans laquelle 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 exécutez 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 devez définir des groupes de journaux et configurer des agents pour les analyser. Les journaux sont stockés dans le service Object Storage. 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 les éléments suivants à votre groupe dynamique dans la section Règles de mise en correspondance, en remplaçant l'ID Oracle Cloud par votre compartiment.
    instance.compartment.id = '<compartment_ocid>'
    Exemple :
    instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa4ws3242343243244nyb423432rwqsxigt2sia'
  • Stratégie permettant au groupe dynamique d'interagir avec le service de journalisation. Pour créer une stratégie, cliquez sur Identité et sécurité dans le menu de navigation. Sous Identité, cliquez sur Stratégies, puis sur Créer une stratégie.
    Allow dynamic-group <my-group> to use log-content in compartment <target_compartment_name>
    Exemple :
    Allow dynamic-group okelogging to use log-content in compartment BlockchainTeam
Après avoir satisfait aux prérequis, procédez comme suit 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 log, puis sélectionnez Logs.
  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 qui a été créé précédemment.
  4. Sur la deuxième page de l'assistant Créer un journal personnalisé, créez une configuration d'agent pour le journal personnalisé, en indiquant 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 de fichier suivant, qui est la valeur par défaut pour les conteneurs d'application. Sélectionnez Chemin de journal dans la liste Type d'entrée. Entrez le chemin de fichier suivant pour Chemins de fichier. Ce chemin inclut tous les journaux de conteneurs, y compris les conteneurs système et de service.
    /var/log/pods/*/*/*.log
  6. Attendez que les journaux soient inclus. Généralement, les journaux sont ingérés en 3 à 5 minutes.
  7. Sélectionnez Journaux, puis accédez 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 Object Storage.
    1. Crée un connecteur. Sous Journalisation, sélectionnez Connecteurs, puis cliquez sur Créer un connecteur. Sélectionnez Logging en tant que source et Object Storage en tant que cible.
    2. Configurez la source et la cible selon vos besoins.
    3. Sous la section Activer les journaux, définissez Activer le journal sur Activé pour le connecteur que vous avez créé. Le panneau Créer un journal apparaît, avec une valeur par défaut pour la durée de conservation des journaux.
    4. Attendez que les journaux soient inclus. Généralement, 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 Object Storage.

Pour plus d'informations, reportez-vous à Surveillance des clusters 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 Elastic Stack. Les étapes suivantes ont été testées avec Fluentd v1.16.2 et Elasticsearch 7.9.1. Utilisez ces versions ou une version ultérieure 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 les 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 le commentaire d'une seule des lignes suivantes.
    • Annulez le commentaire @include file-fluent.conf si vous écrivez dans un fichier dans le chemin /tmp/obp.log.
    • Annulez le commentaire @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 pod Fluentd ou du noeud Kubernetes.
  5. Pour envoyer les journaux à Elastic Stack, 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 de blocs local sur chaque noeud.
    1. Créez un volume de blocs pour chaque noeud, attachez le volume et créez un répertoire nommé /u01.
    2. Formatez le volume de blocs attaché pour le système de fichiers ext4.
    3. Montez le répertoire /u01 sur le chemin du périphérique.
    4. Modifiez le fichier de déploiement Fluentd (fluentd.yaml) de sorte que le volume de journaux soit /u01, et non /tmp, comme indiqué dans le fragment 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 désormais visibles dans le répertoire /u01 de chaque noeud.

Définition du niveau de journalisation pour les pods d'opérateur

Vous pouvez définir le niveau de journalisation pour les pods hlf-operator et obp-operator. Les étapes de définition du niveau de journalisation diffèrent selon que Oracle Blockchain Platform est installé ou non. 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 définir le niveau de journalisation sur debug, info ou error. Dans l'exemple suivant, le niveau de journalisation est défini sur 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 journalisation 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
Une fois les arguments de conteneur mis à jour, la définition de déploiement peut ressembler au texte suivant :
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error