---
schema_version: "1"
id: c8bda6769f7feb1de14ae5ee2a3db7f06dfc40f50982e94e8d516d7c57c9892a
title: Implantação do Helm Chart
collection: tableau
version: current
locale: pt-br
portal_url: https://docs.salesforce.com/tableau/current/pt-br/server-linux/server-helm-deploy.md
canonical_url: https://help.tableau.com/current/server-linux/pt-br/server-helm-deploy.htm
source_site: help.tableau.com
content_type: documentation
content_hash: 972e842aae06dcc70b8054013ffe25749e590a257d01aa4e9e7b1633fde3d4f0
description: "Importante: esta documentação pressupõe um conhecimento do Helm e de Helm Charts e não tenta fornecer exemplos prescritivos detalhados"
---
[Pular para o conteúdo principal](#main-content)

# Tableau Server Helm Chart - Implantação

**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](https://help.tableau.com/current/server-linux/pt-br/server-helm-prerequisites.htm).

### Download do Helm Chart

Os Helm Charts serão enviados como parte da ferramenta de configuração Tableau Server em um contêiner (`tableau-server-container-setup-tool-<version>.tar.gz`) e pode ser baixado na página [Download do Tableau Server](http://tableau.com/pt-br/support/releases/server/latest).

Após a extração, os arquivos dos Helm Charts necessários ficam em `helm/tableau` .

## 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](https://help.tableau.com/current/server-linux/pt-br/server-helm-prerequisites.htm) para obter mais informações.

### Adicionar sua chave de licença a values.yaml

Edite `values.yaml` e defina sua chave de ativação de licença.

### 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)](https://help.tableau.com/current/server-linux/pt-br/server-helm-prerequisites.htm#EKS-Prereq-storageclass) 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)](https://help.tableau.com/current/server-linux/pt-br/server-helm-prerequisites.htm#EKS-Prereq-storageclass) 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)](https://help.tableau.com/current/server-linux/pt-br/server-helm-prerequisites.htm#EKS-Prereq-storageclass) 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](https://help.tableau.com/current/server-linux/pt-br/server_process_index-and-search.htm) e [Serviço de coordenação do Tableau Server](https://help.tableau.com/current/server-linux/pt-br/server_process_coordination.htm).

### 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

#### Implantação com um único nó

A implantação com um único nó executa o Tableau Server como um contêiner monolítico.

Use `values-single.yaml` ou defina:

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

#### Implantação com múltiplos nós

A implantação de múltiplos nós executa um principal e um ou mais trabalhadores. Defina o número de trabalhadores com `worker.replicaCount` — Use 1, 2 ou qualquer valor superior permitido pela capacidade do cluster e pela topologia do Tableau. O gráfico cria `tableau-server-worker-0 … tableau-server-worker-(N-1)` para `replicaCount: N`.

Use `values-multinode.yaml` (o exemplo padrão usa dois trabalhadores) ou defina explicitamente:

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

#### Configuração da imagem

image:  
  repository: tableau\_server\_image  
  tag: "latest"  
  pullPolicy: IfNotPresent  
  pullSecrets: \[\]

#### Licença e segredos

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, s`ecrets.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.

#### Repositório PostgreSQL externo

O Helm Chart não habilita um repositório externo por padrão usando chaves de valores dedicadas.

Recomendamos que você siga estas etapas para habilitar um repositório externo:

1. Implante o Chart e confirme se o primário está intacto.
2. Executar os comandos `tsm external repository` do Tableau no pod primário.
3. Aplique as alterações pendentes.

Exemplo de fluxo de trabalho (descoberta de comandos e aplicação):

\# 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'

Observações:

- A configuração do repositório externo é específica para a versão do Tableau usada (modo SSL, opções de failover, campos de credenciais). Para obter mais informações, consulte [Repositório externo do Tableau Server](https://help.tableau.com/current/server-linux/pt-br/server_external_repo.htm) e a [tsm topology](https://help.tableau.com/current/server-linux/pt-br/cli_topology_tsm.htm).
- No caso de implantações de clientes, armazene credenciais de banco de dados em segredos do Kubernetes e evite usar texto simples no histórico do shell.

#### 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](https://kubernetes.io/DCs/concepts/services-network/ingress)
- [Guia de implantação de ingress-nginx](https://kubernetes.github.io/ingress-nginx/deploy/)
- [Introdução ao cert-manager](https://cert-manager.io/docs/tutorials/getting-started-aks-letsencrypt/)

#### 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

#### Acessar o Tableau Server

Após a instalação, acesse o Tableau Server com base na configuração do seu serviço:

- **ClusterIP**: usar encaminhamento de porta ou entrada
- **NodePort**: acesso via `<node-ip>:<node-port>`
- **Load Balancer**: acesso via IP externo fornecido

#### Usar comandos TSM

\# 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

#### Usar o tabcmd

\# 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

#### Visualizar logs do Tableau Server

\# 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

#### Acesso via shell

\# 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](https://help.tableau.com/current/server-linux/pt-br/server-helm-troubleshooting.htm).

## Recursos adicionais

- [Documentação do Tableau Server](https://help.tableau.com/current/server-linux/en-us/)
- [Documentação do Helm](https://helm.sh/docs/)
- [Atualização do Helm Chart](https://helm.sh/docs/helm/helm_upgrade/)