1. Oracle Blockchain Platform verwalten
  2. Logging

7 Logging

Sie können Oracle Cloud Infrastructure (OCI) oder externe Tools verwenden, um das persistente Logging für Oracle Blockchain Platform Enterprise Edition zu konfigurieren.

Überblick

Oracle Blockchain Platform Enterprise Edition basiert auf Kubernetes, wobei Logs lokal auf jedem Pod gespeichert werden. Um zu verhindern, dass Logs beim Löschen eines Pods gelöscht werden, müssen Sie das persistente Logging einrichten, bei dem Logs an einem zentralen Speicherort gespeichert werden. Es gibt zwei Methoden, die Sie für das persistente Logging verwenden können. Sie können ein externes Loggingtool wie Fluentd und Elastic Stack verwenden. Alternativ können Sie die zentralisierte Logginglösung verwenden, die von Oracle Cloud Infrastructure (OCI) unterstützt wird, wenn Sie auf Oracle Kubernetes Engine ausgeführt werden.

Persistentes Logging mit OCI

Um Logs mit OCI zentral zu speichern, definieren Sie Loggruppen und konfigurieren Agents zum Parsen der Logs. Die Logs werden im Object Storage-Service gespeichert. Bevor Sie das persistente Logging mit OCI konfigurieren, muss Ihr Deployment die folgenden Anforderungen erfüllen.
  • Eine dynamische Gruppe im Kubernetes-Compartment. Um eine dynamische Gruppe zu erstellen, klicken Sie im Navigationsmenü auf Identität und Sicherheit. Klicken Sie unter ID auf Domains und dann auf Dynamische Gruppe erstellen. Fügen Sie der dynamischen Gruppe im Abschnitt Abgleichsregeln Folgendes hinzu, indem Sie die Oracle Cloud-ID für Ihr Compartment ersetzen.
    instance.compartment.id = '<compartment_ocid>'
    Beispiel:
    instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa4ws3242343243244nyb423432rwqsxigt2sia'
  • Eine Policy, mit der die dynamische Gruppe mit dem Logging-Service interagieren kann. Um eine Policy zu erstellen, klicken Sie im Navigationsmenü auf Identität und Sicherheit. Klicken Sie unter ID auf Policys und dann auf Policy erstellen.
    Allow dynamic-group <my-group> to use log-content in compartment <target_compartment_name>
    Beispiel:
    Allow dynamic-group okelogging to use log-content in compartment BlockchainTeam
Nachdem Sie die Voraussetzungen erfüllt haben, führen Sie die folgenden Schritte aus, um Logs zentral mit OCI zu speichern.
  1. Klicken Sie auf das Menüsymbol in der oberen linken Ecke, suchen Sie nach log, und wählen Sie Logs aus.
  2. Loggruppe erstellen. Wählen Sie unter Logging die Option Loggruppen aus, und klicken Sie auf Loggruppe erstellen.
  3. Erstellen Sie ein benutzerdefiniertes Log. Wählen Sie unter Logging die Option Logs aus, und klicken Sie auf Benutzerdefiniertes Log erstellen, um den Assistenten Benutzerdefiniertes Log erstellen zu öffnen. Wählen Sie die zuvor erstellte Loggruppe aus.
  4. Erstellen Sie auf der zweiten Seite des Assistenten Benutzerdefiniertes Log erstellen eine Agent-Konfiguration für das benutzerdefinierte Log, und geben Sie das Kubernetes-Compartment und die dynamische Gruppe an.
  5. Konfigurieren Sie im Abschnitt Logeingaben konfigurieren der Seite Agent-Konfiguration die Logeingabe für den Agent so, dass der folgende Dateipfad verwendet wird. Dies ist der Standard für Anwendungscontainer. Wählen Sie in der Liste Eingabetyp die Option Logpfad aus. Geben Sie den folgenden Dateipfad für Dateipfade ein. Dieser Pfad enthält alle Containerprotokolle, einschließlich System- und Dienstcontainer.
    /var/log/pods/*/*/*.log
  6. Warten Sie, bis Logs aufgenommen wurden. In der Regel werden Protokolle in 3-5 Minuten aufgenommen.
  7. Wählen Sie Logs aus, navigieren Sie zum benutzerdefinierten Log, und klicken Sie auf Log explorieren. Sie können die Logs analysieren, parsen und filtern.
  8. Sie können die Logs auch mit OCI im Object Storage-Service speichern.
    1. Connector erstellen. Wählen Sie unter Logging die Option Connectors aus, und klicken Sie auf Connector erstellen. Wählen Sie Logging als Quelle und Object Storage als Ziel aus.
    2. Konfigurieren Sie die Quelle und das Ziel nach Bedarf.
    3. Setzen Sie im Abschnitt Logs aktivieren für den erstellten Connector die Option Log aktivieren auf Aktiviert. Der Bereich Log erstellen wird mit einem Standardwert für die Logaufbewahrungszeit angezeigt.
    4. Warten Sie, bis Logs aufgenommen wurden. In der Regel werden Protokolle in 3-5 Minuten aufgenommen. In den Connector-Logs werden dann Lese- und Schreibvorgänge angezeigt. Logs werden jetzt in den Object Storage-Service geschrieben.

Weitere Informationen finden Sie unter Kubernetes- und OKE-Cluster mit OCI Logging Analytics überwachen.

Persistentes Logging mit externen Tools

Mit Fluentd und Elastic Stack können Sie Protokolle zentral speichern. Die folgenden Schritte wurden mit Fluentd v1.16.2 und Elasticsearch 7.9.1 getestet. Verwenden Sie diese Versionen oder höher, wenn Sie diese Schritte ausführen.
  1. Erstellen Sie einen Kubernetes-Namespace namens fluentd.
  2. Mit dem folgenden Befehl können Sie eine rollenbasierte Zugriffskontrollressource erstellen.
    kubectl create -f fluentd-rbac.yaml -n fluentd
    Verwenden Sie die folgende fluentd-rbac.yaml-Datei mit dem Befehl.
    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. Mit dem folgenden Befehl können Sie ein ConfigMap-Objekt für Fluentd oder Elastic Stack erstellen.
    kubectl create -f fluentd-configmap_removefilter_ascii.yaml -n fluentd
    Verwenden Sie die folgende fluentd-configmap_removefilter_ascii.yaml-Datei mit dem Befehl.
    Entfernen Sie in der folgenden Datei das Nummernzeichen (#), um nur eine der folgenden Zeilen zu entfernen.
    • Entfernen Sie die Kommentarzeichen für @include file-fluent.conf, wenn Sie in eine Datei im /tmp/obp.log-Pfad schreiben.
    • Entfernen Sie die Kommentarzeichen für @include elastic-fluent.conf, wenn Sie an Elasticsearch schreiben.
    Die folgende Datei zeigt ein Beispiel für das Schreiben in den Pfad /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. Verwenden Sie den folgenden Befehl, um ein DaemonSet-Objekt für Fluentd zu erstellen. Mit diesem Befehl wird auf jedem Knoten ein Fluentd-Pod erstellt.
    kubectl create -f fluentd.yaml -n fluentd
    Verwenden Sie die folgende fluentd.yaml-Datei mit dem Befehl:
    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
    Die Oracle Blockchain Platform-Logs sind im Verzeichnis /tmp des Fluentd-Pods oder des Kubernetes-Knotens verfügbar.
  5. Um die Logs an Elastic Stack zu senden, erstellen Sie einen Kubernetes-Namespace namens elastic-kibana.
  6. Mit dem folgenden Befehl können Sie ein Deployment für Elastic Stack erstellen und als Service bereitstellen.
    kubectl create -f elastic.yaml -n elastic-kibana
    Verwenden Sie die folgende elastic.yaml-Datei mit dem Befehl:
    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. Anschließend können Sie die Logdaten im Elasticsearch-Index mit den folgenden Befehlen prüfen.
    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. Sie können das Log auch mit Fluentd auf dem lokalen Block-Volume auf jedem Knoten speichern.
    1. Erstellen Sie für jeden Knoten ein Block-Volume, hängen Sie das Volume an, und erstellen Sie ein Verzeichnis namens /u01.
    2. Formatieren Sie das angehängte Block-Volume für das Dateisystem ext4.
    3. Hängen Sie das Verzeichnis /u01 am Gerätepfad ein.
    4. Ändern Sie die Fluentd-Deployment-Datei (fluentd.yaml), sodass das Log-Volume /u01 und nicht /tmp ist, wie im folgenden Snippet gezeigt.
      - name: logs
        hostPath:
          path: /u01
    5. Führen Sie den folgenden Befehl aus, um das Fluentd-Deployment anzuwenden.
      kubectl apply -f fluentd.yaml -n fluentd
    6. Die Logs sind jetzt im Verzeichnis /u01 auf jedem Knoten sichtbar.

Logebene für Operatorpods festlegen

Sie können die Logebene für die Pods hlf-operator und obp-operator festlegen. Die Schritte zum Festlegen der Logebene unterscheiden sich je nachdem, ob Oracle Blockchain Platform installiert ist. Wenn Oracle Blockchain Platform Enterprise Edition noch nicht installiert ist, führen Sie die folgenden Schritte aus.

  1. Öffnen Sie die entsprechende deployment.yaml-Datei zur Bearbeitung. Die Datei für den hlf-operator-Pod befindet sich in folgendem Verzeichnis:
    distribution_package_location/distribution-package/operators/helmcharts/hlf-operator/templates/deployment.yaml
    Die Datei für den obp-operator-Pod befindet sich in folgendem Verzeichnis:
    distribution_package_location/distribution-package/operators/helmcharts/obp-operator/templates/deployment.yaml
  2. Fügen Sie der Datei folgende Zeile hinzu. Wie im Kommentar gezeigt, können Sie die Logebene auf debug, info oder error setzen. Im folgenden Beispiel wird die Logebene auf info gesetzt.
    --zap-log-level=info # debug, info, error
Nachdem Sie die Datei bearbeitet haben, könnte dieser Abschnitt der Datei wie folgt aussehen:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error

Wenn Oracle Blockchain Platform bereits installiert ist, führen Sie den folgenden Schritt aus.

  • Mit den folgenden Befehlen können Sie die Deployment-Definitionen für die Pods hlf-operator und obp-operator bearbeiten. Fügen Sie das Argument hinzu, das die Logebene für den manager-Container unter der Podvorlagenspezifikation konfiguriert, oder aktualisieren Sie es.
    kubectl edit deployment -n obp-cp obp-operator
kubectl edit deployment -n obp-cp hlf-operator-controller-manager
Nachdem Sie die Containerargumente aktualisiert haben, sieht die Deployment-Definition möglicherweise wie folgt aus:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error