7 Logging

Você pode usar o OCI (Oracle Cloud Infrastructure) ou ferramentas externas para configurar o registro em log persistente para o Enterprise Edition do Oracle Blockchain Platform.

Visão geral

O Oracle Blockchain Platform Enterprise Edition é baseado no Kubernetes, onde os logs são armazenados localmente em cada pod. Para evitar que os logs sejam excluídos quando um pod é excluído, configure o log persistente, em que os logs são armazenados em um local central. Há dois métodos que você pode usar para log persistente. Você pode usar uma ferramenta de log externa, como Fluentd e Elastic Stack. Como alternativa, se você estiver executando no Oracle Kubernetes Engine, poderá usar a solução de registro em log centralizado suportada pela Oracle Cloud Infrastructure (OCI).

Log Persistente com o OCI

Para armazenar logs centralmente usando o OCI, defina grupos de logs e configure agentes para fazer parsing dos logs. Os logs são armazenados no serviço Object Storage. Antes de configurar o registro em log persistente com o OCI, sua implantação deve atender aos seguintes requisitos.
  • Um grupo dinâmico no compartimento do Kubernetes. Para criar um grupo dinâmico, clique em Identidade e Segurança no menu de navegação. Em Identidade, clique em Domínios e, em seguida, clique em Criar grupo dinâmico. Adicione o seguinte ao seu grupo dinâmico na seção Regras de correspondência, substituindo o ID do Oracle Cloud pelo compartimento.
    instance.compartment.id = '<compartment_ocid>'
    Por exemplo:
    instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa4ws3242343243244nyb423432rwqsxigt2sia'
  • Uma política que permite que o grupo dinâmico interaja com o serviço de log. Para criar uma política, clique em Identidade e Segurança no menu de navegação. Em Identidade, clique em Políticas e, em seguida, clique em Criar Política.
    Allow dynamic-group <my-group> to use log-content in compartment <target_compartment_name>
    Por exemplo:
    Allow dynamic-group okelogging to use log-content in compartment BlockchainTeam
Depois de atender aos pré-requisitos, conclua as etapas a seguir para armazenar logs centralmente usando o OCI.
  1. Clique no ícone de menu no canto superior esquerdo, procure log e selecione Logs.
  2. Criar um grupo de logs. Em Registro em Log, selecione Grupos de Logs e clique em Criar Grupo de Logs.
  3. Crie um log personalizado. Em Log, selecione Logs e clique em Criar log personalizado para abrir o assistente de Criação de log personalizado. Selecione o grupo de logs criado anteriormente.
  4. Na segunda página do assistente de Criação de log personalizado, crie uma configuração de agente para o log personalizado, especificando o compartimento do Kubernetes e o grupo dinâmico.
  5. Na seção Configurar entradas de log da página Configuração do agente, configure a entrada de log para que o agente use o caminho de arquivo a seguir, que é o padrão para contêineres de aplicativos. Selecione Caminho do log na lista Tipo de entrada. Informe o caminho de arquivo a seguir para Caminhos de arquivo. Esse caminho inclui todos os logs de contêineres, incluindo contêineres de sistema e serviço.
    /var/log/pods/*/*/*.log
  6. Aguarde até que os logs sejam ingeridos. Normalmente, os logs são ingeridos em 3 a 5 minutos.
  7. Selecione Logs e navegue até o log personalizado e clique em Explorar Log. Você pode analisar, analisar e filtrar os logs.
  8. Você também pode usar o OCI para armazenar os logs no serviço Object Storage.
    1. Criar um conector. Em Log, selecione Conectores e clique em Criar Conector. Selecione Logging como a Origem e o Object Storage como o Destino.
    2. Configure a origem e o destino conforme necessário.
    3. Na seção Ativar logs, defina Ativar Log como Ativado para o conector que você criou. O painel Criar Log é exibido, com um valor padrão para o tempo de retenção de log.
    4. Aguarde até que os logs sejam ingeridos. Normalmente, os logs são ingeridos em 3 a 5 minutos. Em seguida, você pode ver as operações de leitura e gravação nos logs do conector. Os logs agora estão sendo gravados no serviço Object Storage.

Para obter mais informações, consulte Monitorar clusters do Kubernetes e do OKE com o OCI Logging Analytics.

Log Persistente com Ferramentas Externas

Você pode armazenar logs centralmente usando o Fluentd e o Elastic Stack. As seguintes etapas foram testadas com Fluentd v1.16.2 e Elasticsearch 7.9.1. Use essas versões ou versões posteriores ao concluir essas etapas.
  1. Crie um namespace do Kubernetes chamado fluentd.
  2. Use o comando a seguir para criar um recurso de controle de acesso baseado em função.
    kubectl create -f fluentd-rbac.yaml -n fluentd
    Use o arquivo fluentd-rbac.yaml a seguir com o 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. Use o comando a seguir para criar um objeto ConfigMap para o Fluentd ou o Elastic Stack.
    kubectl create -f fluentd-configmap_removefilter_ascii.yaml -n fluentd
    Use o arquivo fluentd-configmap_removefilter_ascii.yaml a seguir com o comando.
    No arquivo a seguir, remova o sinal de número (#) para cancelar o comentário de apenas uma das linhas a seguir.
    • Remova o comentário de @include file-fluent.conf se estiver gravando em um arquivo no caminho /tmp/obp.log.
    • Remova o comentário @include elastic-fluent.conf se estiver escrevendo para o Elasticsearch.
    O arquivo a seguir mostra um exemplo de gravação no caminho /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. Use o comando a seguir para criar um objeto DaemonSet para o Fluentd. Esse comando cria um pod Fluentd em cada nó.
    kubectl create -f fluentd.yaml -n fluentd
    Use o arquivo fluentd.yaml a seguir com o 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
    Os logs do Oracle Blockchain Platform estão disponíveis no diretório /tmp do pod Fluentd ou do nó do Kubernetes.
  5. Para enviar os logs para o Elastic Stack, crie um namespace do Kubernetes chamado elastic-kibana.
  6. Use o comando a seguir para criar uma implantação para Elastic Stack e expô-la como um serviço.
    kubectl create -f elastic.yaml -n elastic-kibana
    Use o arquivo elastic.yaml a seguir com o 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. Em seguida, você pode usar os comandos a seguir para examinar os dados de log no índice do 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. Você também pode usar o Fluentd para armazenar o log no volume em blocos local em cada nó.
    1. Crie um volume em blocos para cada nó, anexe o volume e crie um diretório chamado /u01.
    2. Formate o volume em blocos anexado para o sistema de arquivos ext4.
    3. Monte o diretório /u01 no caminho do dispositivo.
    4. Altere o arquivo de implantação Fluentd (fluentd.yaml) para que o volume de logs seja /u01, não /tmp, conforme mostrado no trecho de código a seguir.
      - name: logs
              hostPath:
                path: /u01
    5. Execute o comando a seguir para aplicar a implantação do Fluentd.
      kubectl apply -f fluentd.yaml -n fluentd
    6. Os logs agora estão visíveis no diretório /u01 em cada nó.

Definir o Nível de Log para Pods do Operador

Você pode definir o nível de log para os pods hlf-operator e obp-operator. As etapas para definir o nível de log são diferentes, dependendo se o Oracle Blockchain Platform está instalado. Se o Oracle Blockchain Platform Enterprise Edition ainda não estiver instalado, conclua as etapas a seguir.

  1. Abra o arquivo deployment.yaml correspondente para edição. O arquivo do pod hlf-operator está no seguinte local:
    distribution_package_location/distribution-package/operators/helmcharts/hlf-operator/templates/deployment.yaml
    O arquivo do pod obp-operator está no seguinte local:
    distribution_package_location/distribution-package/operators/helmcharts/obp-operator/templates/deployment.yaml
  2. Adicione a linha a seguir ao arquivo. Conforme mostrado no comentário, você pode definir o nível de log como debug, info ou error. No exemplo a seguir, o nível de log é definido como info.
    --zap-log-level=info # debug, info, error
Depois de editar o arquivo, essa seção do arquivo poderá ser semelhante ao seguinte texto:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error

Se o Oracle Blockchain Platform já estiver instalado, conclua a etapa a seguir.

  • Use os comandos a seguir para editar as definições de implantação dos pods hlf-operator e obp-operator. Adicione ou atualize o argumento que configura o nível de log do contêiner manager na especificação do modelo de pod.
    kubectl edit deployment -n obp-cp obp-operator
    kubectl edit deployment -n obp-cp hlf-operator-controller-manager
Depois de atualizar os argumentos do contêiner, a definição de implantação poderá ser semelhante ao seguinte texto:
containers:
    - args:
    - --enable-leader-election
    - --zap-log-level=info # debug, info, error