Importante: esta documentação pressupõe um conhecimento do Helm e de Helm Charts e não tenta fornecer exemplos prescritivos detalhados. Ele foi criado para clientes que estão familiarizados com o Tableau Server e com o Helm e Helm Charts.

Este tópico orienta você nas etapas de alto nível de implantação do Tableau Server no Kubernetes usando um Helm Chart.

Pré-requisitos

Antes de começar, verifique se os pré-requisitos foram atendidos. Para obter mais informações, consulte Tableau Server Helm Chart - Pré-requisitos.

Visão geral rápida sobre usar um Helm Chart para implantar o Tableau Server

Importante: esta é uma descrição básica e de alto nível da implantação do Tableau Server usando Helm Charts. Não se destina a representar um procedimento completo. Pressupõe conhecimento do Helm e dos Helm Charts.

Antes de começar, certifique-se de que você atendeu aos pré-requisitos para implantação do Tableau Server usando Helm Charts. Consulte Tableau Server Helm Chart - Pré-requisitos para obter mais informações.

Implantar o Tableau Server com um único nó

Implante uma instância com um único nó do Tableau Server executando esses comandos em um prompt (substitua o namespace da sua versão por <namespace>, por exemplo tableau ou default):

helm install tableau-server ./helm/tableau-server \
  -n <namespace> \
  --create-namespace \
  -f ./helm/tableau-server/values-single.yaml

Implantar o Tableau Server com múltiplos nós

Implante uma instância com múltiplos nós do Server executando esses comandos em um prompt e usando a mesma convenção de namespace como a que está acima:

helm install tableau-server ./helm/tableau-server \
-n <namespace> \
--create-namespace \
-f ./helm/tableau-server/values-multinode.yaml

Pasta de execução com múltiplos nós do EKS (namespace + PV de bootstrap estático)

Esta seção descreve a ordem de operações do EKS: namespace dedicado, complemento do CSI do EFS, IAM na função de nó, PV de bootstrap estático e Helm.

1. Crie um namespace dedicado.

   Deve corresponder a claimFef.namespace no PV de bootstrap. Este exemplo usa tableau.

   kubectl create namespace tableau-server
   kubectl get namespace tableau

2. Confirme se o complemento do CSI do EFS existe.

   Se o complemento estiver ausente, crie-o e aguarde até que o status seja ACTIVE:

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

3. Confirme a Storageclass:

   efs-bootstrap Storageclass — Execute se ainda não estiver instalado. Consulte Pré-requisitos do Amazon Elastic Kubernetes Service (EKS) para obter mais informações.

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

4. Confirme o PV de bootstrap estático.

   claimRef deve referir-se ao mesmo namespace e nome de PVC que o Helm Chart cria (tableau-server-bootstrap). Substituir fs-... com o ID do sistema de arquivos EFS:

   cat > /tmp/tableau-bootstrap-pv.yaml <<'EOF'
   apiVersion: v1
   kind: PersistentVolume
   metadata:
     name: tableau-bootstrap-pv
   spec:
     capacity:
       storage: 1Gi
     volumeMode: Filesystem
     accessModes:
       - ReadWriteMany
   persistentVolumeReclaimPolicy: Retain
   storageClassName: efs-bootstrap
   claimRef:
     namespace: tableau
     name: tableau-server-bootstrap
   csi:
     driver: efs.csi.aws.com
     volumeHandle: <fs-xxxxxxxxxxxxxxxxx>
   EOF
   kubectl apply -f /tmp/tableau-bootstrap-pv.yaml
   kubectl get pv tableau-bootstrap-pv

5. IAM na função de instância do nó.

   Anexe o cliente EFS e as políticas somente leitura do EC2. Consulte Pré-requisitos do Amazon Elastic Kubernetes Service (EKS) para saber mais sobre como resolver <your-node-instance-role> do grupo de nós.

   efs-bootstrap Storageclass — Execute se ainda não estiver instalado. Consulte Pré-requisitos do Amazon Elastic Kubernetes Service (EKS) para obter mais informações.

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

6. Valores

   Em values-multinode.yaml (ou uma sobreposição), defina o modo do PV como estático manualmente

   persistence:
     bootstrap:
       createPV: false
       volumeName: tableau-bootstrap-pv
       storageClass: efs-bootstrap

7. Garanta que image.repository, image.tag e os segredos/Licença estejam definidos conforme necessário.

8. Instalar o Helm Chart

   Instale o Helm Chart no mesmo namespace que o PV claimRef:

   helm install tableau-server ./helm/tableau-server \
     -n tableau \
     -f ./helm/tableau-server/values-multinode.yaml

9. Verifique o armazenamento e os pods:

   kubectl get pv,pvc -n tableau
   kubectl get pods -n tableau -w

10. Status do PVC de dados

    PVCs de dados podem ser mostrar o status Pending rapidamente até que os volumes do EBS sejam anexados. Todos os PVCs devem fazer a transição para Bound, depois Running e, por fim, READY 1/1.

11. Topologia (opcional)

    Se o gancho pós-instalação estiver desabilitado, talvez seja necessário definir o nó clustercontroller e aplicar as alterações pendentes (consulte Automação da topologia pós-instalação (Gancho) posteriormente neste documento). O comando tsm pending-changes apply pode resultar em avisos sobre a distribuição do Index and Search Server ou o ensemble do Serviço de coordenação quando você tem vários nós do Tableau. Trate esses avisos conforme documentado em Index and Search Server e Serviço de coordenação do Tableau Server.

Instalação personalizada

1. Personalizar valores

   cp ./helm/tableau-server/values.yaml 
   ./helm/tableau-server/my-values.yaml
   # Edit ./helm/tableau-server/my-values.yaml with your configuration

2. Instalar com valores personalizados

   helm install tableau-server ./helm/tableau-server -f ./helm/tableau-server/my-values.yaml

Configuração

Modos de implantação

deploymentMode: "single"
primary:
  replicaCount: 1
worker:
  replicaCount: 0

deploymentMode: "multinode"
primary:
  replicaCount: 1
worker:
  replicaCount: 3    # example: three workers

Alinhamento de topologia: values-multinode.yaml envio com amostra config.configJson topologia (IDs de nós, como node1, node2, node3). Se você alterar worker.replicaCount ou reorganizar os serviços, atualize essa topologia (e quaisquer atribuições de processos do Tableau relacionadas) para que o número e as funções dos nós do TSM correspondam à sua implantação, consulte a ajuda do Tableau Server sobre clustering e layout de processos.

Opções de configuração de chave

image:
  repository: tableau_server_image
  tag: "latest"
  pullPolicy: IfNotPresent
  pullSecrets: []

secrets:
  licenseKey: "YOUR-LICENSE-KEY"
  tsmRemotePassword: "password"
  tableauUsername: "admin"
  tableauPassword: "password"

Como alternativa, você pode definir esses parâmetros usando variáveis de ambiente:

env:
  LICENSE_KEY: "YOUR-LICENSE-KEY"
  TSM_REMOTE_PASSWORD: "password"
  TABLEAU_USERNAME: "admin"
  TABLEAU_PASSWORD: "password"

Recomendamos usar um arquivo separado (por exemplo, secrets.yaml) e passá-lo com o alternador -f.

secrets.yaml:

secrets:
  licenseKey: "YOUR-LICENSE-KEY"
  tsmRemotePassword: "YOUR-TSM-PASSWORD"
  tableauUsername: "YOUR-ADMIN-USER"
  tableauPassword: "YOUR-ADMIN-PASSWORD"

Exemplo de instalação/atualização com secrets.yaml:

helm upgrade --install tableau-server ./helm/tableau-server \
  -n default \
  -f ./helm/tableau-server/values-multinode.yaml \
  -f ./helm/tableau-server/secrets.yaml

Observação: fazer referência a um segredo do Kubernetes pré-existente (por exemplo, secrets.existingSecret) não é aceito no momento. O único método compatível é o uso de valores de Chart com um arquivo com valores de segredos separado.

# Discover command syntax for your Tableau version
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm topology external-services repository enable --help'
# After enabling external repository with Tableau-supported args/options:
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm pending-changes apply -iw --ignore-prompt'
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm status -v'

Armazenamento persistente

persistence:
  enabled: true
  storageClass: "standard"
  accessMode: ReadWriteOnce
  size: 100Gi

  # Bootstrap volume (required for multi-node)
  bootstrap:
    enabled: true
    storageClass: "standard"
    accessMode: ReadWriteMany
    size: 1Gi
    createPV: false

Para clusters que usam CSI do EFS estático (por exemplo, com mounttargetip), o Helm pode gerenciar PV e o PVC de bootstrap:

persistence:
  bootstrap:
    enabled: true
    storageClass: "efs-bootstrap"
    accessMode: ReadWriteMany
    size: 1Gi
    createPV: true
    permissionsFix:
      enabled: true
    pv:
      name: "tableau-bootstrap-pv"
      csi:
        driver: efs.csi.aws.com
        volumeHandle: "fs-xxxxxxxx"
        volumeAttributes:
          mounttargetip: "10.x.x.x"

permissionsFix.enabled adiciona um contêiner de init que chown/chmods /docker/config/bootstrap para que o processo do Tableau (UID/GID 999:998) possa gravar o bootstrap.json em montagens de EFS compartilhadas com o padrão root:root.

Quando createPV: true, o gráfico cria o PV de bootstrap com base em valores (por exemplo, tableau-bootstrap-pv) e vincula tableau-server-bootstrap a ele.

Se você gerencia o PV de bootstrap manualmente, crie tableau-bootstrap-pv primeiro e, em seguida, instale o Helm com createPV: false e volumeName: tableau-bootstrap-pv:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: tableau-bootstrap-pv
spec:
  capacity:
    storage: 1Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: efs-bootstrap
  csi:
    driver: efs.csi.aws.com
    volumeHandle: fs-xxxxxxxx
    volumeAttributes:
      mounttargetip: 10.x.x.x

kubectl apply -f tableau-bootstrap-pv.yaml
kubectl get pv tableau-bootstrap-pv

Limites de recursos

primary:
  resources:
    limits:
      cpu: "4"
      memory: "8Gi"
    requests:
      cpu: "2"
      memory: "4Gi"

worker:
  resources:
    limits:
      cpu: "4"
      memory: "8Gi"
    requests:
      cpu: "2"
      memory: "4Gi"

Configuração de serviço

service:
  primary:
    type: ClusterIP  # or NodePort, LoadBalancer
    ports:
      http: 80
      https: 8080
      tsm: 8850

Entrada

ingress:
  enabled: true
  className: "nginx"
  hosts:
    - host: tableau.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: tableau-tls
      hosts:
        - tableau.example.com

Pasta de execução de configuração de entrada (exemplo: Controlador de entrada NGINX)

1. Instale um controlador de entrada no cluster (obrigatório antes de habilitar a entrada do Chart).

2. Defina os valores de entrada no arquivo de valores:

   ingress:
     enabled: true
     className: "nginx"
     annotations:
       nginx.ingress.kubernetes.io/proxy-body-size: "64m"
       nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
       nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
     hosts:
       - host: tableau.example.com
         paths:
           - path: /
             pathType: Prefix
     tls:
       - secretName: tableau-tls
         hosts:
           - tableau.example.com

3. Crie o registro DNS apontando Tableau.example.com para seu endpoint de balanceador de entrada/carga.

4. Crie um segredo TLS (ou use cert-manager) no namespace da versão.

5. Gráfico de implantação/atualização e verifique a entrada:

   helm upgrade --install tableau-server ./helm/tableau-server -n default -f ./helm/tableau-server/values.yaml
   kubectl get ingress -n default
   kubectl describe ingress tableau-server

Para obter mais informações, consulte:

• Conceito de entrada do Kubernetes

• Guia de implantação de ingress-nginx

• Introdução ao cert-manager

Verificações de integridade

O Chart oferece suporte a sondas de inicialização, atividade e prontidão. A investigação da inicialização permite uma inicialização longa (por exemplo, failedThreshold: 200 × PeriodSeconds) antes da execução de atividade/prontidão:

healthChecks:
  startup:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 15
    timeoutSeconds: 30
    failureThreshold: 200
  liveness:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 30
    timeoutSeconds: 10
    failureThreshold: 3
  readiness:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 10
    timeoutSeconds: 5
    failureThreshold: 3

Para pods de trabalho com múltiplos nós, o Chart usa o padrão worker.healthChecks.enabled: false para evitar falhas de investigação falsa quando os trabalhadores executam conjuntos de processos limitados (por exemplo, agente de administração + controlador de cluster somente).

Uso

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Run tabcmd
kubectl exec -it $POD_NAME -- tsm status
kubectl exec -it $POD_NAME -- tsm configuration get

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Run tabcmd
kubectl exec -it $POD_NAME -- tabcmd login -u admin -p password
kubectl exec -it $POD_NAME -- tabcmd sites

# Primary node logs
kubectl logs -l app.kubernetes.io/component=primary -f

# Worker node logs (multi-node)
kubectl logs -l app.kubernetes.io/component=worker -f

# All logs
kubectl logs -l app.kubernetes.io/instance=tableau-server -f

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Open shell
kubectl exec -it $POD_NAME -- /bin/bash

Atualizar

Atualizar o Helm Chart do Tableau Server

helm upgrade tableau-server ./helm/tableau-server -f ./helm/tableau-server/values.yaml

Atualizar com novos valores

helm upgrade tableau-server ./helm/tableau-server -f ./helm/tableau-server/new-values.yaml

Automação de topologia pós-instalação (hook)

Para instalações com múltiplos nós, este Chart pode executar uma tarefa de hook pós-instalação/pós-atualização que:

• aguarda que os nós trabalhadores se registrem no TSM

• define a atribuição de processo do trabalhador clustercontroller

• executa tsm pending-changes apply -iw --ignore-prompt quando alterações estão pendentes

Configuração:

hooks:
  autoApplyWorkerTopology:
    enabled: true
    kubectlImage: "bitnami/kubectl:latest"
    timeoutSeconds: 3600

Padrões:

• Desabilitado em values.yaml

• em values-multinode.yaml, verifique hooks.autoApplyWorkerTopology.enabled (pode ser true ou false dependendo da versão; habilitar para a configuração clustercontroller de trabalhador não manipulado)

Verifique a execução do hook:

kubectl get jobs -n default
kubectl get pods -n default -l job-name=tableau-server-hook-topology
kubectl logs -n default job/tableau-server-hook-topology

Fallback manual se o hook estiver desabilitado ou falhar; executar tsm topology set-process para cada nó do TSM trabalhador (normalmente node2 até node(1+N) quando você tem N trabalhadores; confirme os IDs usando tsm topology list-nodes -v):

kubectl exec -n default tableau-server-primary-0 -- sh -lc '
tsm topology set-process -n node2 -pr clustercontroller -c 1
tsm topology set-process -n node3 -pr clustercontroller -c 1
# Add one line per additional worker node, e.g. for four workers:
# tsm topology set-process -n node4 -pr clustercontroller -c 1
# tsm topology set-process -n node5 -pr clustercontroller -c 1
tsm pending-changes apply -iw --ignore-prompt
tsm topology list-nodes -v

tsm status -v

Nota: não use -iw ou tsm pending-changes apply. A opção -ig não é válida neste ambiente.

Desinstalação

helm uninstall tableau-server

Aviso: isso excluirá todos os recursos, incluindo os volumes persistentes. Certifique-se de fazer backup dos dados antes de desinstalar.

Etapas de validação

Antes do lançamento ou ao alterar o Chart, execute:

1. Lint:

   helm lint helm/tableau-server -f helm/tableau-server/values-single.yaml
   helm lint helm/tableau-server -f helm/tableau-server/values-multinode.yaml

2. Modelo (exemplo):

   helm template tableau-server helm/tableau-server -f helm/tableau-server/values-single.yaml
   helm template tableau-server helm/tableau-server -f helm/tableau-server/values-multinode.yaml

3. Teste de instalação (opcional):

   1. Em um namespace de teste, execute helm install com values-single ou values-multinode..

   2. Execute kubectl rollout status (para StatisticalSet, aguarde o pod Pronto) e verificações básicas de ativação (por exemplo, tsm status ou HTTP para o serviço).

Para uma solução de problemas detalhada, consulte Tableau Server Helm Chart - Solução de problemas.

Recursos adicionais

• Documentação do Tableau Server
• Documentação do Helm
• Atualização do Helm Chart