1. Amministrazione di Oracle Blockchain Platform
  2. Log

7 Logging

Puoi utilizzare Oracle Cloud Infrastructure (OCI) o strumenti esterni per configurare la registrazione 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 la registrazione 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, definire i gruppi di log e configurare gli agenti per analizzare i 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 in uso.
    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 superiore sinistro, cercare il log, quindi selezionare Log.
  2. Crea 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 di file, che è l'impostazione predefinita per i contenitori applicazione. Selezionare Percorso log dalla lista Tipo di input. Immettere il seguente percorso file per 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 ingeriti in 3-5 minuti.
  7. Selezionare Log, quindi passare 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 degli 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 ingeriti in 3-5 minuti. È quindi possibile visualizzare le operazioni di lettura e scrittura nei log del connettore. È ora in corso la scrittura dei log 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. Al termine della procedura, utilizzare queste versioni o versioni successive.
  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 ruolo.
    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 annullare il commento a una sola delle righe seguenti.
    • Eliminare il commento a @include file-fluent.conf se si sta scrivendo in un file nel percorso /tmp/obp.log.
    • Eliminare il commento @include elastic-fluent.conf se si sta 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 seguente comando per creare un oggetto DaemonSet per Fluentd. Questo comando crea un pod Fluentd su ogni nodo.
    kubectl create -f fluentd.yaml -n fluentd
    Utilizzare 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 del nodo Kubernetes.
  5. Per inviare i log a Elastic Stack, creare uno spazio di nomi Kubernetes denominato elastic-kibana.
  6. Utilizzare il comando riportato di seguito per creare una distribuzione per Elastic Stack ed esporla come servizio.
    kubectl create -f elastic.yaml -n elastic-kibana
    Utilizzare 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 seguenti comandi 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. Formatta 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 seguente.
      - 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 su ogni nodo.

Impostazione del livello di log per i pod 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 dell'installazione di Oracle Blockchain Platform. 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 avere un aspetto 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 seguente.

  • Utilizzare i comandi riportati di seguito 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 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 di distribuzione potrebbe avere un aspetto simile al testo seguente:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error