Esta página foi traduzida pela API Cloud Translation.

Configure o servidor de registos central

Esta página descreve como configurar um servidor de registos central para dispositivos de appliance isolados do Google Distributed Cloud (GDC) através da organização do centro de dados isolado do Google Distributed Cloud.

Para criar uma localização de registo central, o dispositivo GDC tem de ter os seguintes componentes na organização do centro de dados do GDC:

projeto único
contentor para os registos de auditoria
Recipiente para registos operacionais

Criar um projeto

Os seguintes passos têm de ser realizados na organização do centro de dados do GDC para a qual os registos vão ser exportados.

Defina KUBECONFIG para a API Org Management:
```
export KUBECONFIG=ORG_MANAGEMENT_API_KUBECONFIG_PATH
```
Nota: para a arquitetura de organização do centro de dados do GDC antigo, este é o kubeconfig para o cluster de administrador da organização.
Para receber as autorizações necessárias para exportar registos, peça ao administrador de IAM da sua organização para lhe conceder a função ClusterRole Project Creator (ClusterRole project-creator). Para mais informações sobre estas funções, consulte o artigo Prepare as autorizações de IAM.

Aplique o recurso personalizado do projeto para criar um projeto exclusivo para o dispositivo GDC a partir do qual os registos vão ser exportados:

kubectl apply -f - <<EOF
apiVersion: resourcemanager.gdc.goog/v1
kind: Project
metadata:
  namespace: platform
  name: APPLIANCE_PROJECT_NAME
  labels:                                                                                                                                                                                                                                                                   
    object.gdc.goog/tenant-category: user                                                                                                                                   
EOF

Verifique se o novo projeto está disponível no dispositivo GDC:
```
kubectl get namespace APPLIANCE_PROJECT_NAME
```
Associe o novo projeto a uma conta de faturação. Para acompanhar os custos dos recursos do projeto, tem de ter uma conta de faturação associada ao seu projeto.
Para obter as autorizações necessárias para exportar registos, peça ao administrador de IAM da organização que lhe conceda a função de administrador de IAM do projeto (project-iam-admin) no espaço de nomes APPLIANCE_PROJECT_NAME.

Crie um contentor

Os seguintes passos têm de ser realizados pelo administrador da plataforma (PA) na organização do centro de dados do GDC para a qual os registos vão ser exportados.

Defina KUBECONFIG para a API Org Management:
```
export KUBECONFIG=ORG_MANAGEMENT_API_KUBECONFIG_PATH
```
Nota: para a arquitetura de organização do centro de dados do GDC antigo, este é o kubeconfig para o cluster de administrador da organização.
Para receber as autorizações de que precisa para exportar registos, peça ao administrador de IAM da organização para lhe conceder a função de administrador do contentor de projetos (project-bucket-admin) no espaço de nomes APPLIANCE_PROJECT_NAME.

Aplique o recurso personalizado de contentor para criar um contentor:

apiVersion: object.gdc.goog/v1
kind: Bucket
metadata:
  name: BUCKET_NAME
  namespace: APPLIANCE_PROJECT_NAME
  labels:                                                                                                                                                                     
    object.gdc.goog/bucket-type: normal                                                                                                                                       
    object.gdc.goog/encryption-version: v2                                                                                                                                    
    object.gdc.goog/tenant-category: user
spec:                                                                                                                                                                         
  description: Bucket for storing appliance xyz audit logs                                                                                                                     
  location: zone1                                                                                                                                                             
  storageClass: Standard

Depois de criar o contentor, execute o seguinte comando para confirmar e verificar os detalhes do contentor:
```
kubectl describe buckets BUCKET_NAME -n APPLIANCE_PROJECT_NAME
```

Crie uma ProjectServiceAccount para aceder a objetos no contentor.

kubectl apply -f - <<EOF
---
apiVersion: resourcemanager.gdc.goog/v1
kind: ProjectServiceAccount
metadata:
  name: BUCKET_NAME-read-write-sa
  namespace: APPLIANCE_PROJECT_NAME
spec: {}
EOF

Verifique se o ProjectServiceAccount é propagado:

kubectl get projectserviceaccount BUCKET_NAME-read-write-sa -n APPLIANCE_PROJECT_NAME -o json | jq '.status'

Certifique-se de que o ServiceAccount tem as autorizações read e write adicionadas para o contentor.

kubectl apply -f - <<EOF
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: BUCKET_NAME-read-write-role
  namespace: APPLIANCE_PROJECT_NAME
rules:
- apiGroups:
  - object.gdc.goog
  resourceNames:
  - BUCKET_NAME
  resources:
  - buckets
  verbs:
  - read-object
  - write-object
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: BUCKET_NAME-read-write-rolebinding
  namespace: APPLIANCE_PROJECT_NAME
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: BUCKET_NAME-read-write-role
subjects:
- kind: ServiceAccount
  name: BUCKET_NAME-read-write-sa
  namespace: APPLIANCE_PROJECT_NAME
EOF

Obtenha o segredo que contém as credenciais de acesso para o contentor:

kubectl get secret -n APPLIANCE_PROJECT_NAME -o json| jq --arg jq_src BUCKET_NAME-read-write-sa '.items[].metadata|select(.annotations."object.gdc.goog/subject"==$jq_src)|.name'

O resultado tem de ser semelhante ao seguinte exemplo, onde é apresentado o nome secreto do contentor:

"object-storage-key-sysstd-sa-olxv4dnwrwul4bshu37ikebgovrnvl773owaw3arx225rfi56swa"

Exporte o valor para uma variável:

export BUCKET_RW_SECRET_NAME=BUCKET_RW_SECRET_NAME

Obtenha o ID da chave para o acesso ao contentor:

kubectl get secret $BUCKET_RW_SECRET_NAME -n appliance-xyz -o json | jq -r '.data."access-key-id"' | base64 -di

O resultado tem de ser semelhante ao seguinte exemplo:

PCEW2HU47Y8ACUWQO4SK

Obtenha a chave de acesso secreta para o contentor:

kubectl get secret $BUCKET_RW_SECRET_NAME -n appliance-xyz -o json | jq -r '.data."secret-access-key"' | base64 -di

O resultado tem de ser semelhante ao seguinte exemplo:

TzGdAbgp4h2i5UeiYa9k09rNPFQ2tkYADs67+65E

Obtenha o ponto final do contentor:

kubectl get bucket BUCKET_NAME -n APPLIANCE_PROJECT_NAME -o json | jq '.status.endpoint'

O resultado tem de ser semelhante ao seguinte exemplo:

https://objectstorage.org-1.zone1.google.gdch.test

Obtenha o nome totalmente qualificado do contentor:

kubectl get bucket BUCKET_NAME -n APPLIANCE_PROJECT_NAME -o json | jq '.status.fullyQualifiedName'

O resultado tem de ser semelhante ao seguinte exemplo:

aaaoa9a-logs-bucket

Transfira dados do GDC

Siga os passos em Exporte registos para um contentor remoto para transferir registos do dispositivo GDC para o contentor criado anteriormente no centro de dados isolado do GDC usando o ponto final do contentor, o nome totalmente qualificado, o ID da chave de acesso e a chave de acesso secreta.

Configure o Loki e o Grafana no centro de dados isolado do Google Distributed Cloud

Os passos seguintes têm de ser realizados pelo operador de infraestrutura (IO) na organização do centro de dados isolado do GDC para o qual os registos foram exportados.

Obtenha funções de IAM

Para receber as autorizações de que precisa para exportar registos, peça ao administrador de IAM da sua organização que lhe conceda a função de administrador de restauro de registos (logs-restore-admin) no espaço de nomes obs-system no cluster de infraestrutura e as funções de visualizador de origens de dados (datasource-viewer) e editor de origens de dados (datasource-editor) no espaço de nomes obs-system no plano de gestão.

Configure o Loki

Defina KUBECONFIG para o cluster de infraestrutura da organização:
```
export KUBECONFIG=ORG_INFRA_CLUSTER_KUBECONFIG_PATH
```

Obtenha o ID da chave de acesso e a chave de acesso secreta para o contentor de registos do dispositivo a partir do PA e crie um segredo que contenha as credenciais no espaço de nomes obs-system:

kubectl create secret generic -n obs-system APPLIANCE_LOGS_BUCKET_SECRET_NAME 
--from-literal=access-key-id=APPLIANCE_LOGS_BUCKET_ACCESS_KEY_ID 
--from-literal=secret-access-key=APPLIANCE_LOGS_BUCKET_SECRET_ACCESS_KEY

Obtenha o ponto final e o nome totalmente qualificado do contentor de registos do dispositivo a partir da PA e crie um Loki configmap:

kubectl apply -f - <<EOF
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: CONFIGMAP_NAME
  namespace: obs-system
data:
  loki.yaml: |-
    auth_enabled: true
    common:
      ring:
        kvstore:
          store: inmemory
    compactor:
      working_directory: /data/loki/compactor
      compaction_interval: 10m
      retention_enabled: true
      retention_delete_delay: 2h
      retention_delete_worker_count: 150
      delete_request_store: s3
    ingester:
      chunk_target_size: 1572864
      chunk_encoding: snappy
      max_chunk_age: 2h
      chunk_idle_period: 90m
      chunk_retain_period: 30s
      autoforget_unhealthy: true
      lifecycler:
        ring:
          kvstore:
            store: inmemory
          replication_factor: 1
          heartbeat_timeout: 10m
      wal:
        enabled: false
    limits_config:
      discover_service_name: []
      retention_period: 48h
      reject_old_samples: false
      ingestion_rate_mb: 256
      ingestion_burst_size_mb: 256
      max_streams_per_user: 20000
      max_global_streams_per_user: 20000
      max_line_size: 0
      per_stream_rate_limit: 256MB
      per_stream_rate_limit_burst: 256MB
      shard_streams:
        enabled: false
        desired_rate: 3MB
    schema_config:
      configs:
      - from: "2020-10-24"
        index:
          period: 24h
          prefix: index_
        object_store: s3
        schema: v13
        store: tsdb
    server:
      http_listen_port: 3100
      grpc_server_max_recv_msg_size: 104857600
      grpc_server_max_send_msg_size: 104857600
      graceful_shutdown_timeout: 60s
    analytics:
      reporting_enabled: false
    storage_config:
      tsdb_shipper:
        active_index_directory: /tsdb/index
        cache_location: /tsdb/index-cache
        cache_ttl: 24h
      aws:
        endpoint: APPLIANCE_LOGS_BUCKET_ENDPOINT
        bucketnames: APPLIANCE_LOGS_BUCKET_FULLY_QUALIFIED_NAME
        access_key_id: ${S3_ACCESS_KEY_ID}
        secret_access_key: ${S3_SECRET_ACCESS_KEY}
        s3forcepathstyle: true
---
EOF

Crie um Loki statefulset e um serviço:

kubectl apply -f - <<EOF
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    app: STATEFULSET_NAME
  name: STATEFULSET_NAME
  namespace: obs-system
spec:
  persistentVolumeClaimRetentionPolicy:
    whenDeleted: Retain
    whenScaled: Retain
  podManagementPolicy: OrderedReady
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: STATEFULSET_NAME
  serviceName: STATEFULSET_NAME
  template:
    metadata:
      labels:
        app: STATEFULSET_NAME
        istio.io/rev: default
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - preference:
              matchExpressions:
              - key: node-role.kubernetes.io/control-plane
                operator: DoesNotExist
              - key: node-role.kubernetes.io/master
                operator: DoesNotExist
            weight: 1
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - STATEFULSET_NAME
              topologyKey: kubernetes.io/hostname
            weight: 100
      containers:
      - args:
        - -config.file=/etc/loki/loki.yaml
        - -config.expand-env=true
        - -target=all
        env:
        - name: S3_ACCESS_KEY_ID
          valueFrom:
            secretKeyRef:
              key: access-key-ID
              name: APPLIANCE_LOGS_BUCKET_SECRET_NAME
              optional: false
        - name: S3_SECRET_ACCESS_KEY
          valueFrom:
              secretKeyRef:
                key: secret-access-key
                name: APPLIANCE_LOGS_BUCKET_SECRET_NAME
                optional: false
        image: gcr.io/private-cloud-staging/loki:v3.0.1-gke.1
        imagePullPolicy: Always
        livenessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: loki-server
            scheme: HTTP
          initialDelaySeconds: 330
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        name: STATEFULSET_NAME
        ports:
        - containerPort: 3100
          name: loki-server
          protocol: TCP
        - containerPort: 7946
          name: gossip-ring
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: loki-server
            scheme: HTTP
          initialDelaySeconds: 45
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          limits:
            ephemeral-storage: 2000Mi
            memory: 8000Mi
          requests:
            cpu: 300m
            ephemeral-storage: 2000Mi
            memory: 1000Mi
        securityContext:
          readOnlyRootFilesystem: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /etc/loki
          name: config
        - mountPath: /data
          name: loki-storage
        - mountPath: /tsdb
          name: loki-tsdb-storage
        - mountPath: /tmp
          name: temp
        - mountPath: /tmp/loki/rules-temp
          name: tmprulepath
        - mountPath: /etc/ssl/certs
          name: trust-bundle
          readOnly: true
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext:
        fsGroup: 10001
        runAsGroup: 10001
        runAsUser: 10001
      terminationGracePeriodSeconds: 4800
      volumes:
      - emptyDir: {}
        name: temp
      - emptyDir: {}
        name: tmprulepath
      - configMap:
          defaultMode: 420
          name: trust-store-root-ext
          optional: true
        name: trust-bundle
      - configMap:
          defaultMode: 420
          name: CONFIGMAP_NAME
        name: config
  updateStrategy:
    type: RollingUpdate
  volumeClaimTemplates:
  - apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      creationTimestamp: null
      name: loki-storage
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 5Gi
      storageClassName: standard-rwo
      volumeMode: Filesystem
  - apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      creationTimestamp: null
      name: loki-tsdb-storage
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 5Gi
      storageClassName: standard-rwo
      volumeMode: Filesystem
---
apiVersion: v1
kind: Service
metadata:
  name: STATEFULSET_NAME
  namespace: obs-system
spec:
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - name: loki-server
    port: 3100
    protocol: TCP
    targetPort: loki-server
  selector:
    app: STATEFULSET_NAME
  sessionAffinity: None
  type: ClusterIP
---
EOF

Configure o Grafana `DataSource`

Defina KUBECONFIG para a API Org Management:
```
export KUBECONFIG=ORG_MANAGEMENT_API_KUBECONFIG_PATH
```
Nota: para a arquitetura de centro de dados isolada do GDC antigo, este é o kubeconfig para o cluster de administrador da organização.

Crie DataSources para os registos de infraestrutura e plataforma:

kubectl apply -f - <<EOF
---
apiVersion: monitoring.private.gdc.goog/v1alpha1
kind: Datasource
metadata:
  name: INFRA_DATASOURCE_NAME
  namespace: APPLIANCE_PROJECT_NAME-obs-system
spec:
  datasource:
    access: proxy
    isDefault: false
    jsonData:
      httpHeaderName1: X-Scope-OrgID
    name: UI_FRIENDLY_NAME
    orgId: 1
    readOnly: true
    secureJsonData:
      httpHeaderValue1: infra-obs
    type: loki
    uid: INFRA_DATASOURCE_NAME
    url: http://STATEFULSET_NAME.obs-system.svc:3100
    version: 1
    withCredentials: false
---
apiVersion: monitoring.private.gdc.goog/v1alpha1
kind: Datasource
metadata:
  name: PLATFORM_DATASOURCE_NAME
  namespace: APPLIANCE_PROJECT_NAME-obs-system
spec:
  datasource:
    access: proxy
    isDefault: false
    jsonData:
      httpHeaderName1: X-Scope-OrgID
    name: UI_FRIENDLY_NAME
    orgId: 1
    readOnly: true
    secureJsonData:
      httpHeaderValue1: platform-obs
    type: loki
    uid: PLATFORM_DATASOURCE_NAME
    url: http://STATEFULSET_NAME.obs-system.svc:3100
    version: 1
    withCredentials: false
---
EOF

Veja registos no Grafana do centro de dados isolado do Google Distributed Cloud

Os registos exportados para o bucket do centro de dados isolado do Google Distributed Cloud podem ser vistos na instância do Grafana do projeto do dispositivo GDC.

Configure o servidor de registos central Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Criar um projeto

Crie um contentor

Transfira dados do GDC

Configure o Loki e o Grafana no centro de dados isolado do Google Distributed Cloud

Obtenha funções de IAM

Configure o Loki

Configure o Grafana DataSource

Veja registos no Grafana do centro de dados isolado do Google Distributed Cloud

Configure o servidor de registos central

Configure o Grafana `DataSource`