1. Administrando o Oracle Blockchain Platform
  2. Log

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