Dynamisk skalning i en behållare – Tableau Server bakgrundsprocessor

Introduktion

Den dynamiska skalningen av bakgrundsprocessor i en behållare gör att du kan använda olika skalningsstrategier på bakgrundsprocessor- och schemalagda jobb i Tableau Server. Automatisk skalning innebär i detta sammanhang att tjänster kan skalas oberoende för att hantera olika uppgiftsbelastningar utan att behöva mänsklig inblandning eller påverka drifttiden för andra serversystem. Tableau Server-behållare med kompletta noder av Tableau Server-processer kommer att fortsätta att köras som monolitiska system. En mindre uppsättning frikopplade oberoende behållartjänster som omfattar tjänstrollen ”bakgrundsprocessor” kommer istället att vara dynamiskt skalbara och hantera beräkningslast som normalt hanteras av Tableau Server-behållare. Tjänster för bakgrundsprocessor är ansvariga för att bearbeta systemuppgifter som omfattar uppdatering/skapa extrakt, skicka prenumerationer, kontrollera datavarningar och många underhållsjobb. Vid till exempel tillfällen då det är fördelaktigt att uppdatera ett stort antal datauppsättningar eller beräkna många beräkningsmässigt krävande dataaviseringar kan du nu använda Kubernetes och skala upp beräkningskraften för att utföra dessa uppgifter på ett effektivt sätt. Denna guide innehåller konfigurations- och distributionskraven för Automatisk skalning av bakgrundsprocessorer i Kubernetes. Detta dokument är ett komplement till dokumentationen om Tableau Server i en container.

Förutsättningar

Automatisk skalning av bakgrundsprocessorer är endast tillgängligt i Kubernetes och baseras på Tableau Server i behållare. För att kunna använda funktionen Automatisk skalning av bakgrundsprocessorer måste du uppfylla vissa krav:

Begränsningar

  • Den här funktionen fungerar bara som en del av en Linux-baserad distribution.
  • Flödesjobb stöds inte på bakgrundsfunktionerna för automatisk skalning. Flödesjobb kommer att hanteras av bakgrundstjänsterna som fortsätter att köras i Tableau Server-behållaren.

Skapa bilder i Tableau Server och poddar för bakgrundsprocessor

Det första steget för att använda automatisk skalning av bakgrundsprocessorer i behållare är att skapa de tjänstebilder som ingår i Tableau Server-installationen. Dessa bilder omfattar Tableau Server-bilden och även bilder för den separata bakgrundsprocessorn och stödtjänsterna. Du använder samma byggverktyg som används för att skapa den omfattande heltäckande Tableau Server-behållaravbildningen, men verktyget måste vara version 2022.3.0 eller senare, du måste ha en Advanced Management-licens och du måste använda en speciell flagga när du skapar bilderna.

  1. Kör följande kommandot för att skapa tjänstavbildningarna:

    build-image --accepteula -i <installer> --backgrounder-images

    Detta skapar Tableau Server och fyra nya avbildningar. Dessa ytterligare avbildningar innehåller individuella tjänster som utgör den nya automatiskt skalbara bakgrundsprocessorn.

    Kommandot docker images anger avbildningarna som skapats i den lokala Docker-lagringsplatsen:

    hyper                          20214.21.1117.1006             52fd9843c178   10 seconds ago
    gateway                        20214.21.1117.1006             2308e602a2a3   11 seconds ago
    backgrounder                   20214.21.1117.1006             4540e459cf23   12 seconds ago
    dataserver                     20214.21.1117.1006             c5345ed47f51   12 seconds ago
    tableau_server_image           20214.21.1117.1006             b27817047dd1   7 minutes ago

    Hyper-, gateway-, bakgrundsprocessor- och dataserverbilderna utgör den nya podden för bakgrundsprocessor. Anpassade drivrutiner, installationsskript och egenskaper delas mellan alla fem avbildningar. Mer information finns i Anpassa bilden.

  2. Publicera alla dessa avbildningar i ditt interna bildarkiv så att de kan distribueras.

Driftsättningsguide

Följande information ger sammanhang för hur du distribuerar Tableau Server i en behållare och med automatisk skalning av bakgrundsprocessorer. Denna information förutsätter att du redan förstår och känner till hur man distribuerar Tableau Server i en fristående behållare. Mer information finns i Tableau Server i en container. De tre Kubernetes-konfigurationsfilerna i avsnittet Kubernetes-konfiguration är mallar som kan användas för att konfigurera distributionen. De andra avsnitten i den här guiden omfattar distributionens krav och detaljer.

Distribution av Tableau Server och automatisk skalning av bakgrundsprocessorer bör vara lika enkelt som att distribuera de ifyllda Kubernetes-konfigurationsfilerna längst ner i guiden:

kubectl apply -f <tableau-kubeconfig-dir>

Bakgrundsjobb

Poddar för bakgrundsprocessor hjälper Tableau Server i en behållare att beräkna ytterligare schemalagda arbetsbelastningar parallellt. Bakgrundsprocessorn hanterar extraktuppdatering, prenumeration, varning, flöde och systemarbetsbelastningar. Distribuera jobb mellan poddar för bakgrundsprocessor innebär att det kommer att finnas fler beräkningsresurser tillgängliga för Tableau Server för att hantera andra uppgifter. Detta kan var interaktiva användaraktiviteter, t.ex. återgivning av arbetsböcker och instrumentpaneler. Flödesjobb är den enda typen av bakgrundsprocessorjobb som inte körs i bakgrundsprocessorn. Mer information om bakgrundsprocessor finns i Hantera bakgrundsjobb i Tableau Server .

Poddar för bakgrundsprocessor kan hantera alla typer av belastningar, förutom flödesjobb, som måste köras i de Tableau Server-huvudbehållare, som fortsätter att köra bakgrundsprocessortjänsten.

Funktionen Nodroller ger användarna flexibiliteten att dedikera poddar för bakgrundsprocessor till specifika typer av jobb. Denna funktion är en förlängning av funktionen Nodroller på Tableau Server. Här finns en detaljerad beskrivning av olika nodroller. Notera att standardflödesjobb är inaktiverade på poddar för bakgrundsprocessor (dvs. rollen är inställd på ”inga flöden”) eftersom poddar för bakgrundsprocessor inte kan köra flödesjobb.

Om du vill ställa in nodroller för bakgrundsprocessor måste du ställa in miljövariabeln NODE_ROLES som en del av kubeconfig för behållaren som kör poddar för bakgrundsprocessortjänsten. Om du till exempel vill ställa in bakgrundsprocessorn att endast köra extraktuppdateringsjobb ställer du in miljövariabeln NODE_ROLES på extraktuppdatering enligt nedan:

NODE_ROLE_CONFIG

containers:
- name: backgrounder
image: <backgrounder_image> # Backgrounder Image
ports:
- containerPort: 8600
volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
- name: dataengine-volume
mountPath: /docker/dataengine
- name: temp
mountPath: /var/opt/tableau/tableau_server/data/tabsvc/temp
env:
- name: ROOT_LOG_DIR
value: /var/log/tableau
- name: CLONE_ARTIFACT_DIR
value: /docker/clone/clone-artifacts
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
- name: NODE_ROLES
value: extract-refreshes

Tableau Server-poddarna kommer att ha minst en bakgrundsprocessor konfigurerad i sin topologi, vilket krävs för att säkerställa att det alltid finns en plats för att köra bakgrundsprocessor. Som standard kräver TSM att det måste finnas en bakgrundsprocessor som kan hantera varje roll för bakgrundsprocessorjobb. I vissa scenarier kanske du vill ha poddar för bakgrundsprocessor som hanterar alla jobb av en viss typ. För detta måste du ställa in serverkonfigurationsnyckeln topology.roles_handle_all_jobs_constraint_disabledtrue vilket inaktiverar kravet på att TSM-topologin ska hantera alla jobbtyper. När denna parameter anges kan rollen för bakgrundsprocessor för Tableau Server instans för bakgrundsprocessor anges till no-extract-refreshes och rollen för poddar för bakgrundsprocessor kan anges till extract-refreshes. Detta säkerställer att alla extraktuppdateringar endast körs på poddarna för bakgrundsprocessor.

Obs! Om du inaktiverar denna begränsning kan du konfigurera roller så att vissa jobbtyper aldrig schemaläggs. Konfigurationen av roller för TSM-bakgrundsjobb och bakgrundsjobb måste ställas in noggrant eftersom TSM inte längre kommer att verifiera att alla typer av bakgrundsprocessorjobb kan schemaläggas.

Tableau Server i en behållarpodd

Behållarna med Tableau Server som en del av de automatiskt skalade poddarna för bakgrundsprocessor distribueras på nästan samma sätt som vår befintliga Tableau Server i en behållare. Det finns några viktiga kravändringar:

  • En nätverksfilresurs krävs för att överföra konfigurationen mellan Tableau Server-behållaren och poddarna för bakgrundsprocessor.
  • Du måste aktivera och använda funktionen Extern fillagring. Detta kräver också en dedikerad nätverksfilresurs.

Poddar för bakgrundsprocessor

Poddar för bakgrundsprocessor består av fyra oberoende tjänstbehållare som arbetar tillsammans: gateway, hyper, dataserver och bakgrundsprocessor. Du kan distribuera dessa poddar som vanliga oberoende Kubernetes behållarpoddar. Poddarna har följande krav:

  • Poddar för bakgrundsprocessor måste kunna nå Tableau Server-noden med hjälp av värdnamnets DNS-upplösning.
  • Externa filresurser för Filestore- och Clone-nätverk måste tillhandahållas.

Obs! Poddar för bakgrundsprocessor är konfigurerade med en init-behållare som väntar tills Tableau Server-behållaren har producerat klonkonfigurationsutdata innan du fortsätter att köra.

Loggar

Tjänsterna för poddar för bakgrundsprocessor (som Tableau Server) skriver fortfarande loggar huvudsakligen till disken. Eftersom poddarna för bakgrundsprocessor kan skalas in och ut, är de tillfälliga och därför är det viktigt att se till att loggarna förvaras utanför poddarna. Många kunder med befintliga K8s-miljöer kommer redan att använda en loggaggregeringstjänst av något slag för att samla in loggarna från poddarna de distribuerar. Splunk och fluentd är exempel på loggaggregeringstjänster. Vi rekommenderar starkt att kunderna använder någon form av loggaggregeringstjänst för att samla in loggarna från sina poddar för bakgrundsprocessor. För att göra logghanteringen enklare konfigurerar den kubeconfig vi tillhandahåller varje tjänst i podden till att skriva till en delad loggvolym. Sökvägen till katalogen i varje tjänstbehållare anges av miljövariabeln ROOT_LOG_DIR.

Om du behöver öppna ett supportärende och tillhandahålla loggar kommer du att tillhandahålla två uppsättningar loggar: ziplogs som samlats in från serverns huvudbehållare och loggar från poddarna för bakgrundsprocessor (hämtas antingen från din loggaggregeringstjänst eller genom den manuella processen nedan) .

För kunder som inte kan använda en loggaggregeringstjänst kan loggar hämtas manuellt från poddarna.

Obs! Loggar från alla poddar som inte använde ett beständigt volymanspråk för volymen som innehåller loggarna kommer att gå förlorade när podden skalas ner!

Alla relevanta loggar finns tillgängliga i /var/log/tableau-katalogen (konfigurerbara via miljövariabeln ROOT_LOG_DIR) inuti podden för bakgrundsprocessorn. Vi rekommenderar starkt att du monterar en PersistantVolumeClaim på denna plats så att loggar finns tillgängliga när podden dör.

Samlar loggar när podden för bakgrundsprocessorn körs:

Skapa en tar-fil av loggarna inuti behållaren:

kubectl exec -it <backgrounder-pod-name> -- bash -c "tar -czf /docker/user/backgrounder-pod-logs.tar.gz /var/log/tableau"

Kopiera tarfile till utanför behållaren:

kubectl cp <backgrounder-pod-name>:docker/user/backgrounder-pod-logs.tar.gz ./backgrounder-pod-logs.tar.gz
Samlar loggar när podden för bakgrundsprocessorn har avslutats (eller inte kunde starta)

Fäst alla långvariga poddar med PersistantVolumeClaim-monteringen som används för distributionsloggar för poddar för bakgrundsprocessor. Ett exempel på konfiguration:

apiVersion: v1
kind: Pod
metadata:
name: <name>
namespace: <namespace>
spec:
containers:
- name: get-logs-pod
image: busybox:1.28
securityContext:
runAsUser: 0
allowPrivilegeEscalation: true
command: ['sh', '-c', "while :; do sleep 5; done"]
volumeMounts:
- name: logmount
mountPath: /var/log/tableau restartPolicy: Never
volumes:
- name: logmount
persistentVolumeClaim:
claimName: logvolume

Skapa en tar-fil av loggarna inuti behållaren:

kubectl exec -it <backgrounder-pod-name> -- bash -c "tar -czf /backgrounder-pod-logs.tar.gz /var/log/tableau"

Kopiera tarfile till utanför behållaren:

kubectl cp <backgrounder-pod-name>:/backgrounder-pod-logs.tar.gz ./backgrounder-pod-logs.tar.gz

Live-konfigurationsändringar

Om du gör konfigurationsändringar i Tableau Server i en behållare (till exempel med kommandoraden tsm) och vill att dessa konfigurationsändringar ska representeras i poddar för bakgrundsprocessor, måste du köra kommandot klon av tsm-inställningar för att producera en ny uppsättning klonkonfigurationsfiler (”klon nyttolast”).

  1. Använd TSM för att göra konfigurationsändringar i Tableau Server i en behållarpodd och tillämpa konfigurationsändringarna på servern.
  2. Kör följande kommando i Tableau Server i en behållarpodd:

    ## Run this command in the Tableau Server in a Container pod.
    tsm settings clone -d $CLONE_ARTIFACT_DIR

    Detta kommando skapar en ny uppsättning konfigurationsfiler och skriver den till platsen för klona NFS-enheten.

  3. Omfördela era poddar för bakgrundsprocessor. Poddarna bör konfigureras för att använda klona NFS-enheten och kommer att plocka upp den nya konfigurationen.

Skalningsstrategier

Poddar för bakgrundsprocessor kan skalas i Kubernetes med många olika tekniker och strategier. Vi tillhandahåller ett exempel på en skalningsstrategi som ändrar poolstorleken för podden för bakgrundsprocessor baserat på ett tidsschema.

Notera att central bearbetningsenhet och minnesutnyttjande inte är bra mått för skalning av poddar för bakgrundsprocessor. Användning av minne och central bearbetningsenhet skildrar inte exakt den totala belastningskravet på klustret. En podd för bakgrundsprocessor kan till exempel användas maximalt för att uppdatera ett extrakt, men det finns inga ytterligare jobb som väntar i bakgrundsprocessorns jobbkö. I detta fall skulle automatisk skalning inte förbättra jobbets genomströmning.

Schemalagd skalning

Du kan schemalägga en skalningslösning med Kubernetes standardmekanismer som använder cron-jobb.

Ett exempel på Kubernetes konfiguration för detta finns i avsnittet Konfiguration av Kubernetes nedan.

Inställning av Kubernetes

Nya miljövariabler

Förutom de vanliga miljövariablerna för Tableau Server-behållare (se Initiala konfigurationsalternativ) finns det några nya miljövariabler som måste ställas in i Kubernetes-konfigurationen.

MiljövariabelRekommenderat värdeBeskrivning
FILESTORE_MOUNT_PATH/docker/dataenginePlats för montering av katalogen Externt filarkiv. Denna katalog ska peka på datamotorns NFS-katalog som är monterad i varje utplacerad Tableau-behållare. Mer information om extern fillagring finns i Extern fillagring på Tableau Server. Värdet bör vara detsamma för Tableau Server i en behållarpodd och podden för bakgrundsprocessorn.
CLONE_ARTIFACT_DIR/docker/clone/clone-artifactsMonteringsplats för klonkonfigurationskatalog. Denna katalog bör peka på en NFS-katalog monterad i varje Tableau-behållare. Tableau Server kommer att mata ut konfigurationsdata som poddar för bakgrundsprocessor använder för att bli medlemmar i klustret.
ROOT_LOG_DIR/var/log/tableau(Endast poddar för bakgrundsprocessor)

Gemensam loggkatalogplats för alla tjänster som körs i en podd för bakgrundsprocessor.

Portar för poddar för bakgrundsprocessor

Poddar för bakgrundsprocessor består av fyra tjänster, var och en är som standard inställd på att köras på en angiven port. Om du vill ändra porten som tjänsten kopplas till inne i behållaren måste du ange den nyckel som motsvarar tjänstens porttilldelning. Denna typ av konfiguration krävs inte i de flesta fall om det inte finns en behållare för parallell åtkomstpunkt eller någon annan ytterligare komponent som läggs till i podden och skapar konflikter med tjänstens port.

Miljövariabel för portStandard
BACKGROUNDER_PORT8600
DATASERVER_PORT8400
HYPER_PORT8200
GATEWAY_PORT8080

Dataserver använder även port 8300, som inte kan konfigureras om.

Delad nätverkskatalog

Denna distribution av Tableau Server kräver två nätverksdelningar för att fungera korrekt. Notera att dessa nätverkskataloger finns i alla konfigurationsmallar för Tableau Server, bakgrundsprocessor och Kubernetes:

  • Datamotorkatalog (FILESTORE_MOUNT_PATH): Poddar för bakgrundsprocessor kräver funktionen Externt filarkiv. Denna nätverksdelning innehåller extrakt och andra filbaserade artefakter som kommer att delas mellan Tableau Server och poddar för bakgrundsprocessor.
  • Kloningskatalog (CLONE_ARTIFACT_DIR): Tableau Server skriver statisk anslutnings- och konfigurationsinformation till en nätverksdelning. Poddar för bakgrundsprocessor kommer att använda denna information för att bli medlemmar i Tableau Server-klustret. I framtida förhandsversioner kommer denna konfiguration att ingå i standardlivscykeln för Kubernetes konfiguration.

Viktigt! Om du vill distribuera om klustret helt (inklusive en ny Tableau Server-behållare), måste du rensa innehållet i klon NFS mount (annars kommer bakgrundsprocessorns poddar att försöka ansluta till den gamla servern).

Exempel på inställningar av KubernetesName

Obs! Konfigurationsexemplen inkluderar användning av beredskapsavsökning. Du kan använda beredskapsavsökning när Tableau Server i en behållare-distributionen är en TSM-distribution med en enda nod (distributionen kan inkludera flera bakgrundsprocessorpoddar). Du kan inte använda beredskapsavsökning med Tableau Server i en behållare-distributioner med flera noder.

Konfiguration av Tableau Server-behållare

---
apiVersion: v1
kind: Service
metadata:
name: <service_name>
namespace: <namespace>
spec:
selector:
app: <service_name>
ports:
- protocol: TCP
port: 8080
nodePort: <nodeport-number>
name: http
- protocol: TCP
port: 8443
nodePort: <nodeport-number>
name: https
type: NodePort
---
apiVersion: v1
kind: ConfigMap
metadata:
name: configfile
namespace: <namespace>
data:
config.json: |-
{
"configEntities": {
"identityStore": {
"_type": "identityStoreType",
"type": "local"
}
},
"configKeys" : {
"tabadmincontroller.init.smart_defaults.enable" : "false",
"wgserver.domain.ldap.starttls.enabled" : "false"
},
"daysLeftForMaintenanceExpiring" : 0
}
---
apiVersion: v1
kind: ConfigMap
metadata:
name: extrepojsonfile
namespace: <namespace>
data:
config.json: |-
{
"flavor":"generic",
"masterUsername":"<admin-name>",
"masterPassword":"<password>",
"host":"<hostname>",
"port":5432,
"prerequisiteCheckEnabled":false,
"requireSsl":false
}
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: datadir1
namespace: <namespace>
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 50Gi
---
# This is required for multi-node tableau server in container
apiVersion: v1
kind: PersistentVolume
metadata:
name: bootstrapnfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
capacity:
storage: 1Gi
nfs:
server: <nfs-ip>
path: <mount-path>
---
# This is required for multi-node tableau server in container
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: bootstrapnfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
storageClassName: ""
resources:
requests:
storage: 1Mi
---
apiVersion: v1
kind: PersistentVolumn
metadata:
name: clonenfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
capacity:
storage: 1Gi
nfs:
server: <nfs-ip>
path: <mount-path>
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: clonenfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
storageClassName: ""
resources:
requests:
storage: 1Mi
---
apiVersion: v1
kind: PersistentVolume
metadata:
name: dataenginenfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
capacity:
storage: 1Gi
nfs:
server: <nfs-ip>
path: <namespace>
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: dataenginenfs
namespace: <namespace>
spec:
accessModes:
- ReadWriteMany
storageClassName: ""
resources:
requests:
storage: 1Mi
---
apiVersion: v1
kind: Secret
type: Opaque
metadata: name: tableau-server-in-a-container-secrets
namespace: <namespace>
stringData:
license_key: <license_key> # Tableau License Key String
tableau_username: <tableau_username> # Initial admin username in Tableau Server
tableau_password: <tableau_password> # Initial admin password
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: tableau-server
namespace: <namespace>
labels:
app: <service_name>
spec:
selector:
matchLabels:
app: <service_name>
replicas: 1
serviceName: <service_name>
template:
metadata:
labels:
app: <service_name>
spec:
securityContext:
runAsUser: 999
fsGroup: 998
fsGroupChangePolicy: "OnRootMismatch"
terminationGracePeriodSeconds: 120
dnsPolicy: "None"
dnsConfig:
nameservers:
- <dns_ip> # DNS IP for resolving container hostnames
searches:
- <service_name>.<namespace>.svc.<cluster_domain>.<example> # SRV Record
- <namespace>.svc.<cluster_domain>.<example> # SRV Record
- svc.<cluster_domain>.<example> # SRV Record
- <cluster_domain>.<example> # SRV Record
options:
- name: ndots
value: "5"
initContainers: # init containers are optional, to clear directory content if already exists
- name: clean-bootstrap-dir
image: busybox:1.28
securityContext:
runAsUser: 0
allowPrivilegeEscalation: true
volumeMounts:
- name: bootstrap
mountPath: /docker/config/bootstrap
command: ['sh', '-c', 'rm -rf /docker/config/bootstrap/* || true']
- name: clean-clone-artifacts-dir
image: busybox:1.28
securityContext:
runAsUser: 0
allowPrivilegeEscalation: true
volumeMounts:
- name: clone
mountPath: /docker/clone
command: ['sh', '-c', 'rm -rf /docker/clone/clone-artifacts || true']
containers:
- name: <container_name> # Name of container
image: <tableau_server_image> # Tableau Server in Container Image
env:
- name: LICENSE_KEY
valueFrom:
secretKeyRef:
name: tableau-server-in-a-container-secrets
key: license_key
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
- name: SERVER_FOR_INDEPENDENT_SERVICE_CONTAINERS
value: "1"
- name: EXT_REP_JSON_FILE
value: /docker/external-repository/config.json
- name: TABLEAU_USERNAME
valueFrom:
secretKeyRef:
name: tableau-server-in-a-container-secrets
key: tableau_username
- name: TABLEAU_PASSWORD
valueFrom:
secretKeyRef:
name: tableau-server-in-a-container-secrets
key: tableau_password
resources:
requests:
memory: 40Gi
cpu: 15
limits:
memory: 40Gi
cpu: 15
ports:
- containerPort: 8080
volumeMounts:
- name: configmount
mountPath: /docker/config/config.json
subPath: config.json
- name: externalrepomount
mountPath: /docker/external-repository
- name: datadir1
mountPath: /var/opt/tableau
- name: bootstrap
mountPath: /docker/config/bootstrap
- name: clone
mountPath: /docker/clone
- name: dataengine
mountPath: /docker/dataengine
imagePullPolicy: IfNotPresent
startupProbe:
exec:
command:
- /bin/sh
- -c
- /docker/server-ready-check
initialDelaySeconds: 300
periodSeconds: 15
timeoutSeconds: 30
failureThreshold: 200
readinessProbe:
exec:
command:
- /bin/sh
- -c
- /docker/server-ready-check
periodSeconds: 30
timeoutSeconds: 60
livenessProbe:
exec:
command:
- /bin/sh
- -c
- /docker/alive-check
initialDelaySeconds: 600
periodSeconds: 60
timeoutSeconds: 60
volumes:
- name: configmount
configMap:
name: configfile
- name: externalrepomount
configMap:
name: extrepojsonfile
- name: datadir1
persistentVolumeClaim:
claimName: datadir1
- name: bootstrap
persistentVolumeClaim:
claimName: bootstrapnfs
- name: clone
persistentVolumeClaim:
claimName: clonenfs
- name: dataengine
persistentVolumeClaim:
claimName: dataenginenfs

Konfiguration av podd för bakgrundsprocessor

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: logvolume
namespace: <namespace>
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: backgrounder
labels:
app: backgrounder
namespace: <namespace>
spec:
replicas: 2
selector:
matchLabels:
app: backgrounder
template:
metadata:
labels:
app: backgrounder
spec:
securityContext:
runAsUser: 999
runAsGroup: 998
fsGroup: 998 fsGroupChangePolicy: "OnRootMismatch"
hostname: backgrounder
dnsPolicy: "None"
dnsConfig:
nameservers:
- <dns_ip> # DNS IP for resolving container hostnames
searches:
- <service_name>.<namespace>.svc.<cluster_domain>.<example> # SRV Record
- <namespace>.svc.<cluster_domain>.<example> # SRV Record
- svc.<cluster_domain>.<example> # SRV Record
- <cluster_domain>.<example> # SRV Record
options:
- name: ndots
value: "5" initContainers:
- name: init-myservice
image: busybox # This init-container is optional (as long as there is a mechanism to set the log volume directory permissions and the pod waits for clone artifacts)
securityContext:
runAsUser: 0
allowPrivilegeEscalation: true
env:
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
command: ['sh', '-c', "chmod 777 /var/log/tableau && while [ ! -d ${CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS} ]; do sleep 5; done"]
containers:
- name: backgrounder
image: <backgrounder_image> # Backgrounder Image
ports:
- containerPort: 8600 imagePullPolicy: IfNotPresent readinessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
periodSeconds: 30
timeoutSeconds: 60
livenessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
initialDelaySeconds: 600
periodSeconds: 60
timeoutSeconds: 60 volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
- name: dataengine-volume
mountPath: /docker/dataengine
- name: temp
mountPath: /var/opt/tableau/tableau_server/data/tabsvc/temp
env:
- name: ROOT_LOG_DIR
value: /var/log/tableau
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
- name: dataserver
image: <dataserver_image> # Dataserver Image
ports:
- containerPort: 8400 imagePullPolicy: IfNotPresent readinessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
periodSeconds: 30
timeoutSeconds: 60
livenessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
initialDelaySeconds: 600
periodSeconds: 60
timeoutSeconds: 60
volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
- name: dataengine-volume
mountPath: /docker/dataengine
- name: temp
mountPath: /var/opt/tableau/tableau_server/data/tabsvc/temp
env:
- name: ROOT_LOG_DIR
value: /var/log/tableau
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
- name: gateway
image: <gateway_image> # Gateway Image
ports:
- containerPort: 8080 imagePullPolicy: IfNotPresent readinessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
periodSeconds: 30
timeoutSeconds: 60
livenessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
initialDelaySeconds: 600
periodSeconds: 60
timeoutSeconds: 60 volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
- name: dataengine-volume
mountPath: /docker/dataengine
- name: temp
mountPath: /var/opt/tableau/tableau_server/data/tabsvc/temp
env:
- name: ROOT_LOG_DIR
value: /var/log/tableau
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
- name: hyper
image: <hyper_image> # Hyper Image
ports: - containerPort: 8200 imagePullPolicy: IfNotPresent readinessProbe:
exec:
command:
- /bin/sh
- -c
- /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
periodSeconds: 30
timeoutSeconds: 60
livenessProbe:
exec:
command:
- /bin/sh
- -c - /tsm_docker_utils/status_check.sh | grep -E 'ACTIVE|BUSY'
initialDelaySeconds: 600
periodSeconds: 60
timeoutSeconds: 60 volumeMounts:
- name: logmount
mountPath: /var/log/tableau
- name: clone-volume
mountPath: /docker/clone
- name: dataengine-volume
mountPath: /docker/dataengine
- name: temp
mountPath: /var/opt/tableau/tableau_server/data/tabsvc/temp
env:
- name: ROOT_LOG_DIR
value: /var/log/tableau
- name: CLONE_ARTIFACT_DIR_FOR_INDEPENDENT_CONTAINERS
value: /docker/clone/clone-artifacts
- name: FILESTORE_MOUNT_PATH
value: /docker/dataengine
volumes:
- name: clone-volume
nfs:
server: <nfs_ip>
path: <mount_path>
- name: dataengine-volume
nfs:
server: <nfs_ip>
path: /dataengine
- name: logmount
persistentVolumeClaim:
claimName: logvolume
- name: temp
emptyDir: {}

Konfiguration av schemalagd skalning

apiVersion: v1
kind: ServiceAccount
metadata:
name: backgrounder-scaler-service-account
namespace: <namespace> # Namespace
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: scale-backgrounder-pods
namespace: <namespace> # Namespace
subjects:
- kind: ServiceAccount
name: backgrounder-scaler-service-account
roleRef:
kind: ClusterRole
name: cluster-admin
apiGroup: rbac.authorization.k8s.io
---
apiVersion: batch/v1beta1
kind: CronJob
metadata:
name: scale-up-job
namespace: <namespace> # Namespace
spec:
schedule: "0 7 * * *" # Cron Job timing to scale up deployment replicas
jobTemplate:
spec:
template:
spec:
serviceAccountName: backgrounder-scaler-service-account
restartPolicy: OnFailure
containers:
- name: scale
image: bitnami/kubectl:1.21
imagePullPolicy: IfNotPresent
args:
- scale
- --replicas=4
- deployment/backgrounder
---
apiVersion: batch/v1beta1
kind: CronJob
metadata:
name: scale-down-job
namespace: <namespace>
spec:
schedule: "0 9 * * *" # Cron Job timing to scale down deployment replicas
jobTemplate:
spec:
template:
spec:
serviceAccountName: backgrounder-scaler-service-account
restartPolicy: OnFailure
containers:
- name: scale
image: bitnami/kubectl:1.21
imagePullPolicy: IfNotPresent
args:
- scale
- --replicas=2
- deployment/backgrounder

Kubernetes-jobb för att rensa klonkonfiguration (valfritt)

Detta är ett bekvämt Kubernetes-jobb som du kan använda under testning. Om du vill rensa bort klonkonfigurationen som produceras av Tableau Server i en behållare mellan olika distributionskörningar, kan du köra ett jobb som detta för att rensa NFS.

apiVersion: batch/v1
kind: Job
metadata:
name: delete-clone-artifacts-job
namespace: manatee-cluster
spec:
template:
spec:
containers:
- name: delete-clone-artifacts
image: busybox:1.28
command: ['sh', '-c', "rm -rf ${CLONE_ARTIFACT_DIR}"]
env:
- name: CLONE_ARTIFACT_DIR
value: /docker/clone/clone-artifacts
securityContext:
runAsUser: 0
allowPrivilegeEscalation: true
volumeMounts:
- name: clone-volume
mountPath: /docker/clone
restartPolicy: Never
volumes:
- name: clone-volume
nfs:
server: <nfs_ip> # IP for shared NFS directory for clone output
path: /clone