7 Logging

Puoi utilizzare Oracle Cloud Infrastructure (OCI) o strumenti esterni per configurare il log persistente per Oracle Blockchain Platform Enterprise Edition.

Panoramica

Oracle Blockchain Platform Enterprise Edition si basa su Kubernetes, in cui i log vengono memorizzati localmente su ciascun pod. Per impedire l'eliminazione dei log quando un pod viene eliminato, è necessario impostare il log persistente, in cui i log vengono memorizzati in una posizione centrale. Esistono due metodi che è possibile utilizzare per il log persistente. È possibile utilizzare uno strumento di registrazione esterno, ad esempio Fluentd ed Elastic Stack. In alternativa, se sei in esecuzione su Oracle Kubernetes Engine, puoi utilizzare la soluzione di registrazione centralizzata supportata da Oracle Cloud Infrastructure (OCI).

Log persistente con OCI

Per memorizzare i log a livello centrale utilizzando OCI, è necessario definire i gruppi di log e configurare gli agenti per l'analisi dei log. I log vengono memorizzati nel servizio di storage degli oggetti. Prima di configurare il log persistente con OCI, la distribuzione deve soddisfare i requisiti riportati di seguito.
  • Gruppo dinamico nel compartimento Kubernetes. Per creare un gruppo dinamico, fare clic su Identità e sicurezza nel menu di navigazione. In Identità, fare clic su Domini, quindi su Crea gruppo dinamico. Aggiungere quanto segue al gruppo dinamico nella sezione Regole di corrispondenza, sostituendo l'ID Oracle Cloud per il compartimento.
    instance.compartment.id = '<compartment_ocid>'
    Ad esempio:
    instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa4ws3242343243244nyb423432rwqsxigt2sia'
  • Criterio che consente al gruppo dinamico di interagire con il servizio di log. Per creare un criterio, fare clic su Identità e sicurezza nel menu di navigazione. In Identità, fare clic su Criteri, quindi su Crea criterio.
    Allow dynamic-group <my-group> to use log-content in compartment <target_compartment_name>
    Ad esempio:
    Allow dynamic-group okelogging to use log-content in compartment BlockchainTeam
Dopo aver soddisfatto i prerequisiti, completare i passi riportati di seguito per memorizzare i log a livello centrale utilizzando OCI.
  1. Fare clic sull'icona del menu nell'angolo in alto a sinistra, cercare log, quindi selezionare Log.
  2. Creare un gruppo di log In Log selezionare Gruppi di log, quindi fare clic su Crea gruppo di log.
  3. Creare un log personalizzato. In Log selezionare Log, quindi fare clic su Crea log personalizzato per aprire la procedura guidata Crea log personalizzato. Selezionare il gruppo di log creato in precedenza.
  4. Nella seconda pagina della procedura guidata Crea log personalizzato creare una configurazione agente per il log personalizzato, specificando il compartimento Kubernetes e il gruppo dinamico.
  5. Nella sezione Configura input di log della pagina Configurazione agente, configurare l'input di log per l'agente in modo che utilizzi il seguente percorso file, che è quello predefinito per i contenitori applicazione. Selezionare Percorso di log dalla lista Tipo di input. Immettere il percorso file seguente per i percorsi file. Questo percorso include tutti i log dei container, inclusi i container di sistema e di servizio.
    /var/log/pods/*/*/*.log
  6. Attendere che i log vengano inclusi. In genere, i log vengono inclusi in 3-5 minuti.
  7. Selezionare Log, quindi andare al log personalizzato e fare clic su Esplora log. È possibile analizzare, analizzare e filtrare i log.
  8. Puoi anche utilizzare OCI per memorizzare i log nel servizio di storage degli oggetti.
    1. Crea un connettore. In Log selezionare Connettori, quindi fare clic su Crea connettore. Selezionare Log come Origine e Storage oggetti come Destinazione.
    2. Configurare l'origine e la destinazione in base alle esigenze.
    3. Nella sezione Abilita log, impostare Abilita log su Abilitato per il connettore creato. Viene visualizzato il pannello Crea log, con un valore predefinito per il tempo di conservazione dei log.
    4. Attendere che i log vengano inclusi. In genere, i log vengono inclusi in 3-5 minuti. È quindi possibile visualizzare le operazioni di lettura e scrittura nei log del connettore. I log vengono ora scritti nel servizio di storage degli oggetti.

Per ulteriori informazioni, vedere Monitorare i cluster Kubernetes e OKE con OCI Logging Analytics.

Registrazione persistente con strumenti esterni

È possibile memorizzare i log a livello centrale utilizzando Fluentd ed Elastic Stack. I seguenti passaggi sono stati testati con Fluentd v1.16.2 ed Elasticsearch 7.9.1. Utilizzare queste versioni o versioni successive quando si completano queste operazioni.
  1. Creare uno spazio di nomi Kubernetes denominato fluentd.
  2. Utilizzare il comando riportato di seguito per creare una risorsa di controllo dell'accesso basata su ruoli.
    kubectl create -f fluentd-rbac.yaml -n fluentd
    Usare il seguente file fluentd-rbac.yaml con il comando.
    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. Utilizzare il comando seguente per creare un oggetto ConfigMap per Fluentd o Elastic Stack.
    kubectl create -f fluentd-configmap_removefilter_ascii.yaml -n fluentd
    Usare il seguente file fluentd-configmap_removefilter_ascii.yaml con il comando.
    Nel file seguente, rimuovere il segno numerico (#) per separare solo una delle righe seguenti.
    • Annulla il commento a @include file-fluent.conf se si sta scrivendo a un file nel percorso /tmp/obp.log.
    • Annulla il commento a @include elastic-fluent.conf se stai scrivendo a Elasticsearch.
    Il file seguente mostra un esempio di scrittura nel percorso /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. Utilizzare il comando seguente per creare un oggetto DaemonSet per Fluentd. Questo comando crea un pod Fluentd su ogni nodo.
    kubectl create -f fluentd.yaml -n fluentd
    Usare il seguente file fluentd.yaml con il comando.
    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
    I log di Oracle Blockchain Platform sono disponibili nella directory /tmp del pod Fluentd o nel nodo Kubernetes.
  5. Per inviare i log a Elastic Stack, creare uno spazio di nomi Kubernetes denominato elastic-kibana.
  6. Utilizzare il comando seguente per creare una distribuzione per Elastic Stack e per esporla come servizio.
    kubectl create -f elastic.yaml -n elastic-kibana
    Usare il seguente file elastic.yaml con il comando.
    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. È quindi possibile utilizzare i comandi seguenti per esaminare i dati di log nell'indice 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. È inoltre possibile utilizzare Fluentd per memorizzare il log sul volume a blocchi locale su ciascun nodo.
    1. Creare un volume a blocchi per ogni nodo, collegare il volume e creare una directory denominata /u01.
    2. Formattare il volume a blocchi collegato per il file system ext4.
    3. Attivare la directory /u01 sul percorso del dispositivo.
    4. Modificare il file di distribuzione Fluentd (fluentd.yaml) in modo che il volume dei log sia /u01 e non /tmp, come mostrato nello snippet riportato di seguito.
      - name: logs
        hostPath:
          path: /u01
    5. Eseguire il comando seguente per applicare la distribuzione Fluentd.
      kubectl apply -f fluentd.yaml -n fluentd
    6. I log sono ora visibili nella directory /u01 di ogni nodo.

Impostare il livello di log per i pod dell'operatore

È possibile impostare il livello di log per i pod hlf-operator e obp-operator. I passi per impostare il livello di log sono diversi a seconda che Oracle Blockchain Platform sia installato. Se Oracle Blockchain Platform Enterprise Edition non è ancora installato, attenersi alla procedura riportata di seguito.

  1. Aprire il file deployment.yaml corrispondente per la modifica. Il file per il pod hlf-operator si trova nella seguente posizione:
    distribution_package_location/distribution-package/operators/helmcharts/hlf-operator/templates/deployment.yaml
    Il file per il pod obp-operator si trova nella seguente posizione:
    distribution_package_location/distribution-package/operators/helmcharts/obp-operator/templates/deployment.yaml
  2. Aggiungere la riga seguente al file. Come mostrato nel commento, è possibile impostare il livello di log su debug, info o error. Nell'esempio seguente il livello di log è impostato su info.
    --zap-log-level=info # debug, info, error
Dopo aver modificato il file, la sezione del file potrebbe essere simile al testo seguente:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error

Se Oracle Blockchain Platform è già installato, completare il passo riportato di seguito.

  • Utilizzare i comandi seguenti per modificare le definizioni di distribuzione per i pod hlf-operator e obp-operator. Aggiungere o aggiornare l'argomento che configura il livello di log per il contenitore manager nella specifica del modello di pod.
    kubectl edit deployment -n obp-cp obp-operator
kubectl edit deployment -n obp-cp hlf-operator-controller-manager
Dopo aver aggiornato gli argomenti del contenitore, la definizione della distribuzione potrebbe essere simile al testo seguente:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error