Hjälp för Tableau Server på Linux

Begränsningar för Tableau Server i en behållare

• Tableau Server i en behållare stöder endast licensaktivering med hjälp av Server ATR. Offlineaktivering med Server ATR stöds i 2023.1 och senare. Denna funktion är tillgänglig i behållare men kräver extra steg och godkännande. Om du behöver köra Tableau Server i en behållare i en frånkopplad miljö eller offlinemiljö kontaktar du din kontorepresentant för mer information.
• Tableau Server i en container stöder för närvarande inte RMT-agenten (Resource Monitoring Tool).
• Kerberos stöds inte i Tableau Server i en container.

Tableau Server i en behållaravbildning

Tableau Server i en behållaravbildning är en Docker-avbildning som innehåller hela Tableau Server. Avbildningen är byggd med hjälp av Tableau Server i ett behållaravbildningsverktyg. När den har byggts innehåller avbildningen Tableau Server, men är inte initierad ännu. Standardanvändaren i en Tableau Server i en behållaravbildning är en oprivilegierad icke-rot-användare.

Förutsättningar

Kör skriptet configure-container-host

När Tableau Server installeras utan en behållare ändras vissa resursgränser och coredump-egenskaper som en del av installationsprocessen. Detta är för att optimera prestanda för Tableau Server. En Tableau Server i en behållaravbildning har inte möjlighet att göra dessa ändringar på värddatorn, så vi rekommenderar att du kör skriptet configure-container-host som anges i Tableau Server i ett behållarinställningsverktyg på vilken dator som helst som kör Tableau Server i en behållaravbildning. Detta är för att Tableau Server i en behållare-avbildningen ska fungera på samma sätt som dess motsvarande version som körs utan behållare.

Så här kör du skriptet configure-container-host:

1. Leta upp skriptet (configure-container-host) på den översta katalognivån i konfigurationsverktyget för Tableau Server i en behållare.

2. Kopiera det till de miljöer där du planerar att köra Tableau Server.

3. Bestäm vilket oprivilegierade användarkonto/uid som ska köras som standardanvändare av Tableau Server i en behållaravbildning. Den här användaren bör finnas på värddatorn och bör matcha det UID som angetts i Tableau Server-behållarens miljövariabel UNPRIVILEGED_TABLEAU_UID. Om du inte ställde in detta när du skapade din Docker-avbildning, så är standardinställningen för oprivilegierad användar-ID inuti behållaren 999. Om du använder Docker-användarmappning bör detta UID överensstämma med den användare som finns på värddatorn.

4. Kör skriptet som rot:

   sudo ./configure-container-host -u <uid>

Köra avbildningen

Om du vill köra en Tableau Server i en behållardockeravbildning är det enklaste kommandot för att köra en Tableau Server i en behållaravbildning följande:

docker run \
-e LICENSE_KEY=<key>
-p 8080:8080
-d <Tableau Server in a Container image ID or tag>

Detta kör Docker i bakgrunden och, efter en tid, resulterar i en helt installerad instans av Tableau Server. Tableau Server kan ta 10 till 20 minuter att starta upp helt, beroende på hårdvaran i datorn som kör bilden. Du kan bekräfta att containern körs genom att ange kommandot docker ps. När Tableau Server är helt i drift måste det initiala Tableau Server-administratörskontot skapas. Det här steget kan automatiseras. Se Automatisera initial Tableau Server-administratör för mer information.

Sammanfattning av grundläggande körningsargument

Samtliga alternativ som används i Docker-körningskommandot är nödvändiga. Ofta tillhandahålls fler alternativ för att utnyttja olika funktioner i avbildningen. Låt oss ta en närmare titt på argumenten som används i det enklaste Docker-körningskommandot för Tableau Server i en container:

Automatisera initial Tableau Server-administratör

När Tableau Server startar för första gången måste du skapa en initial administratörsanvändare innan fjärrnätverksanslutningar till Tableau Server tillåts. Detta kan du göra genom att köra kommandottabcmd initialuser -s localhost:8080 -u <username> -p <password> inuti behållaren. Du kan också ställa in administratörsuppgifter via miljövariabler. TABLEAU_USERNAME och TABLEAU_PASSWORD eller TABLEAU_PASSWORD_FILE (rekommenderas) är de miljövariabler som kan ställas in för att passera i initiala administratörsuppgifter. Mer information om lösenordshantering finns i Lösenordshantering.

Mer information om kommandot tabcmd initialuser finns i initialuser.

Exempel

docker run \
-e LICENSE_KEY=<key> \
-e TABLEAU_USERNAME=<myadmin> \
-e TABLEAU_PASSWORD_FILE=/etc/tableau-admin-secret \
-v <full-path-to-pw-file>:/etc/tableau-admin-secret \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Licensiering

Licensiering i behållare

Licensiering av Tableau Server i en container använder tjänsten Server Authorization-To-Run (ATR) för att aktivera Tableau Server som är utplacerad i molnet, behållare eller virtuella miljöer utan att ta slut på licensaktiveringar. ATR-tjänsten uppnår detta genom att tillhandahålla kortsiktiga leasingavtal med konfigurerbar varaktighet (ATR-duration) tills produktnyckelns utgångsdatum är går ut. ATR separerar Tableau-licenser från underliggande maskinvaruförändringar, vilket är en grundläggande aspekt av behållardistributioner. Eftersom Server ATR kräver att behållaren ska kunna nå ATR-tjänsten hos Tableau, kräver behållarna internetåtkomst. Tableau Server i en container stöder inte offline eller manuell aktivering. Se Aktivera Tableau Server med tjänsten Auktorisera för körning (ATR) för mer information.

Viktigt: Du måste ange antingen miljövariabeln LICENSE_KEY eller LICENSE_KEY_FILE (ange endast en).

När du uppgraderar Tableau Server i en behållare, om du har använt det maximala antalet aktiveringar för din licens, kan inte Tableau Server starta förrän ATR-tiden har förflutit (4 timmar/14400 sekunder som standard). Mer information om att ställa in eller ändra ATR-tiden finns i Aktivera Tableau Server med tjänsten Auktorisera för körning (ATR)(Länken öppnas i ett nytt fönster).

Licensmiljövariabel

Tableau Server i en behållare har stöd för att ange licensnycklar med en miljövariabel: LICENSE_KEY kan innehålla en eller flera nycklar (-e LICENSE_KEY=”<key1> , <key2>”) via en kommaseparerad lista.

Exempel

docker run \
-e LICENSE_KEY="<key1>, <key2>" \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Licensfil

Tableau Server i en container stöder även inställning av licensnycklar med hjälp av en fil. Montera en fil till standardlicensnyckelfilens plats i behållaren (/docker/config/license_file) eller som på annat sätt anges av miljövariabeln LICENSE_KEY_FILE.

Exempel

docker run \
-v <full-path-to-license-file>:/docker/config/license_file \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Begärd licens leasingtid

Du kan ange ATR-licensens leasingtid i en Tableau Server-behållare genom att ställa in miljövariabeln REQUESTED_LEASE_TIME. Du måste ange leasingtiden i sekunder, med minsta varaktighet på 3600 sekunder (eller 1 timme). Det rekommenderas att du sänker leasingtiden när du experimenterar och testar Tableau Server för att minska sannolikheten för att nå den maximala aktiverade leasinggränsen. För produktionsinstallationer rekommenderar vi starkt att du inte ställer in parametern REQUESTED_LEASE_TIME (och använder därför standardvärdet), så att Tableau kan bestämma den ideala leasingtiden.

Exempel

docker run \
...
-e REQUESTED_LEASE_TIME=<time-in-seconds> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Köra en oinitierad avbildning

Tableau Server har två installationsfaser, först installeras Tableau Service Manager-tjänsterna (TSM). I en typisk lokal installation är det i här steget som serveradministratörerna registrerar sin server, aktiverar sina licenser och konfigurerar servern så att den beter sig på önskat sätt. Den andra fasen av installationen är att installera och starta Tableau Server-processerna som hanterar slutanvändartrafik och relaterad affärslogik.

Standardbeteendet för Tableau Server i en behållaravbildning är att automatisera alla installationssteg så att docker run-kommandot så småningom resulterar i en fullt fungerande server. Men om du vill starta en Tableau Server i en behållaravbildning och att den bara ska köra TSM-tjänsterna (vad en serveradministratör skulle förvänta sig om de bara körde initialize-tsm) genomför du detta genom att skicka TSM_ONLY-flaggan som en miljövariabel.

Exempel:

docker run \
-e TSM_ONLY=1 \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Interagera med avbildningen

När du har en Tableau-server i en behållaravbildning igång kan du anropa TSM- och tabcmd-kommandon direkt. Dessa verktyg läggs till direkt i miljösökvägen för pid 1-användaren (som är rot för närvarande). Detta innebär att du kan anropa TSM- och tabcmd-kommandon enligt följande:

docker exec -it <container> tsm status -v

docker exec -it <container> tabcmd initialuser -s localhost -u <admin> -p <secret>

Det är också möjligt att öppna ett skal i behållaren om du vill utföra mer allmänna åtgärder. Detta rekommenderas normalt inte för annat än i felsökningssyfte:

docker exec -it <container> bash

TSM-webbgränssnitt och fjärr-CLI

TSM-webbgränssnitt och fjärr-CLI är inte tillgängliga som standard. Detta beror på att det krävs ett användarnamn och lösenord för att autentisera och som standard får användaren som kör Tableau Server-processer i behållaren inget lösenord. Detta görs av säkerhetsskäl (vi rekommenderar inte att du skickar bilder med ett standardlösenord inuti dem eftersom det skulle möjliggöra fjärråtkomst). I vissa fall kan TSM-webbgränssnittet och fjärråtkomstsamtal med TSM CLI vara användbart. Om du vill använda dessa funktioner måste du följa stegen nedan och skapa ett användarkonto för fjärråtkomst.

Mer detaljerad information om TSM-webbgränssnitt och CLI finns i Logga in på webbgränssnittet för Tableau Services Manager.

Skapa en TSM-fjärranvändare

Ange miljövariablerna TSM_REMOTE_UID och TSM_REMOTE_USERNAME när du bygger Tableau Server i en behållaravbildning med hjälp av installationsverktyget. Skapande av ett TSM-aktiverat konto i avbildningen kräver privilegierad åtkomst i avbildningen som inte är tillgänglig under körning, och därför kan det bara göras när Docker-avbildningen byggs av Tableau Server i ett behållarinstallationsverktyg (build-image).

Exempel på Tableau Server i en environment-fil för behållarinstallationsverktyget:

TSM_REMOTE_UID=1010
TSM_REMOTE_USERNAME=myuser

Ställ in lösenordet för en TSM-fjärranvändare

Tableau Server i en behållaravbildning kräver ett lösenord för kontot när avbildningen körs. Det finns två sätt att ställa in lösenordet för det här kontot.

Hemlighetsfil (rekommenderas)

Skapa en fil med namnet remote-user-secret, skriv lösenordet i filen och montera den i behållaren vid körning. TSM_REMOTE_PASSWORD_FILE bestämmer den förväntade platsen (standardplatsen är /docker/config/remote-user-secret) för hemlighetsfilen i behållaren.

Exempel på remote-user-secret-fil:

mypassword

Exempel på Docker-körningskommando:

docker run \
-e LICENSE_KEY=<key>
-v {absolute-path}/remote-user-secret:/docker/config/remote-user-secret
-p 8080:8080 \
-p 8850:8850 \
-d <Tableau Server in a Container image ID or tag>

Miljövariabel

Du kan också helt enkelt ställa in miljövariabeln TSM_REMOTE_PASSWORD när du startar Docker-avbildningen.

Exempel på Docker-körningskommando:

docker run \
-e LICENSE_KEY=<key>
-e TSM_REMOTE_PASSWORD=<password>
-p 8080:8080 \
-p 8850:8850 \
-d <Tableau Server in a Container image ID or tag>

Säkerhetsanteckningar

• Port 8850 måste vara exponerad för att ta emot TSM-begäransstrafik.
• Om lösenordet inte är korrekt inställt i avbildningen vid körning avslutas behållaren omedelbart.
• TSM förlitar sig på bildens Linux-användarkontosystem. I det här fallet är kontot begränsat inuti avbildningen. Detta betyder att kontot kommer att ha ett begränsat skal och är begränsat till att utföra två kommandon: /bin/true och passwd.

Hur man roterar TSM-fjärranvändarnas lösenord

Om du vill rotera TSM-fjärranvändarens kontolösenord kan du göra detta med något av följande alternativ:

Starta en ny Tableau Server i en container

Kontots lösenord ställs in varje gång behållaren startar. Om du håller kvar Tableau-data utanför behållaren roteras lösenordet om du startar en ny avbildning med ett nytt lösenord.

1. Stäng av och ta bort den pågående avbildningen
2. Ställ in ett nytt lösenordsvärde i endera av miljövariablerna TSM_REMOTE_PASSWORD eller TSM_REMOTE_PASSWORD_FILE (se ovan) i din bildkonfiguration.
3. Starta avbildningen igen.

Rotera lösenordet manuellt i en behållare som körs

Om du inte vill stänga av avbildningen kan du ändå rotera lösenordet manuellt.

1. Öppna ett skal i behållaren som körs
2. Logga in som fjärranvändarkonto med kommandot su

3. Ändra lösenordet genom att köra kommandot passwd .

   Varning: Dessa manuella rotationer kvarstår bara så länge som behållarinstansens skrivlager finns kvar. Om du tar bort behållaren kommer de manuella ändringarna inte att tillämpas när en ny behållare startas.

Initiala konfigurationsalternativ

Att konfigurera Tableau Server i en container är mycket viktigt om du vill få det Tableau Server-beteende du vill ha. Tableau Server i en container är en ren installation av Tableau Server, så du måste tillhandahålla samma information till behållaren som när du konfigurerar Tableau Server utanför en behållare.

Runtime-miljövariabler

Runtime-miljövariablerna nedan berättar för Tableau Server i en behållaravbildning hur man distribuerar Tableau Server. En del av dessa kommer att beskrivas mer i detalj.

Alla dessa värden är utformade för att åsidosättas, vilket möjliggör större flexibilitet för konfigurationen.

Skrivskyddade miljövariabler

Dessa är miljöegenskaper som beskriver några av de grundläggande egenskaperna för Tableau Server i en behållaravbildning. Det rekommenderas inte att åsidosätta dessa värden.

Byggtidsmiljövariabler

Åsidosättande av Tableau Server-konfiguration

Dessa miljövariabler kan skrivas över av Docker så att de kan peka på vilken fil som helst i behållaren. Så om du vill ange en annan monteringspunkt så är det bara att göra det.

Tableau Server behöver en konfigurationsfil för att kunna startas och köras:

CONFIG_FILE=/docker/config/config.json

CONFIG_FILE hänvisar till en TSM-konfigurationsfil. Formatet och användningen är identisk med konfigurationsfilen som beskrivs i Exempel på konfigurationsfil.

Kommandon före initiering och efter initiering

Tableau Server kör ett automatiserat installationsskript som är utformat för att ta Server från ett förinitierat tillstånd till fullt körande. Men emellanåt vill du kanske lägga till din egen automatiseringskod i initieringsprocessen. Vi erbjuder två sätt att göra detta på – förinitieringsskript och efterinitieringsskript.

Förinitieringsskript

Detta skript körs omedelbart efter det att bas-TSM-processerna har initierats och innan några andra TSM-inställningssteg körs. Detta sätt är användbart när du vill utföra TSM-konfigurationskommandon innan Tableau Server körs. För konfigurationsändringar som görs vid denna tidpunkt behöver du inte tillämpa ändringarna eftersom den normala Tableau Server-automatiseringen gör detta efter det att ditt skript är klart.

Efterinitieringsskript

Det här skriptet körs efter det att all annan Tableau Server-initiering och startautomatisering är klar. Tableau Server kommer att vara fullt fungerande och körs när det här skriptet körs. Konfigurationsändringar som görs vid denna tidpunkt måste tillämpas.

Instruktioner

Om du vill lägga till ett anpassat skript till en av dessa hookar i din avbildning, så följ dessa steg:

1. Skriv ditt anpassade skript
2. Kopiera det anpassade skriptet till customer-files-katalogen i Tableau Server i behållaravbildningsbyggverktyget.
3. Byt namn på skriptet till att vara pre_init_command eller post_init_command beroende på när du vill att skriptet ska köras (du kan använda båda hookarna oberoende av varandra).
4. Se till att behörigheterna för skriptet antingen är körbara av andra (chmod +rx <command-file>) eller att ägarbehörigheterna matchar den oprivilegierade användaren i behållaren.

Användarkonfiguration

Tableau Server använder en oprivilegierad användare för att köra serverprocesser. Denna användare skapades i behållaren när Tableau Server i en container initieras. Användaren heter som standard tableau med ett UID på 999. Om du distribuerar en Tableau-server i en behållare som använder monteringar för att lagra data externt på värddatorn kanske du föredrar att ändra detta UID till att mappa ett till ett UID på värddatorn. Att använda Docker-användarnamnrymder är ett annat sätt att uppnå samma resultat.

Verktyg för Tableau Server i en container

Alla verktygsfunktioner för Tableau Server i en container placeras under denna katalog:

/docker/

Hantering av filbehörighet

Varje gång du skickar konfigurationsfiler till behållaren vill du vara säker på att användaren som kör Tableau Server-processen i behållaren har åtkomstbehörighet till filerna. Undvik att ge alla användare åtkomst till filer som monteras på behållaren genom att ändra UID och/eller GID för användaren som kör Tableau Server i behållaren så att användaren/gruppägaren på värden matchas. Behållaranvändaren kommer att ha ett UID som bestäms av miljövariabeln UNPRIVILEGED_TABLEAU_UID (standard: 999) och GID som bestäms av UNPRIVILEGED_TABLEAU_GID (standard: 998). Du kan ändra dessa värden genom att åsidosätta miljövariabeln eller så kan du använda en Docker-användarnamnrymdsmappning för att associera UID/GID i behållaren till ett annat UID/GID på värden.

Lösenordshantering

Vissa funktioner och alternativ kräver att användaruppgifterna anges som en konfigurationsinställning i behållaren. Tableau Initial Admin-inloggningsuppgifter är ett exempel på valfria inloggningsuppgifter som möjliggör ytterligare funktioner. I dessa fall tillhandahåller vi alltid två metoder för att ställa in lösenordet. Först kan du tillhandahålla en fil som innehåller lösenordet och ange en sökväg till en miljövariabel. Alternativt kan du ställa in en miljövariabel för att lagra lösenordet direkt.

Det rekommenderade och säkrare alternativet är att ange lösenordet som en sökväg till behållaren. Att tillhandahålla en hemlighet i en fil är ett mönster med starkt stöd i Docker, Docker Swarm, Kubernetes och andra behållareorkestreringssystem. Att lagra lösenord direkt i miljövariabler är ett vanligt mönster så vi stöder det, men det betyder vanligtvis att lösenordet är mindre säkert.

Exempel

Låt oss ta en titt på inloggningsuppgifterna för TABLEAU_USERNAME. Du kan ange lösenordet för användaren som antingen TABLEAU_PASSWORD eller TABLEAU_PASSWORD_FILE. När du kör en Tableau-server i en behållaravbildning kan du ange lösenordet genom att tillhandahålla någon av miljövariablerna.

Lösenordsfilens miljövariabel förväntar sig en sökväg i behållaren till en giltig hemlighetsfil. Hemlighetsfilen bör vara en enda rad som innehåller hemligheten.

Exempel på användning av en hemlighetsfil

docker run \
...
-e TABLEAU_USERNAME=admin \
-e TABLEAU_PASSWORD_FILE=/etc/admin-secret \
-v <full-path-to-pw-file>:/etc/admin-secret \
-d <Tableau Server in a Container image ID or tag>

Exempel på innehåll i en hemlighetsfil

mypassword23879172

Ett annat alternativ är att lagra lösenordet direkt i klartext i lösenordsmiljövariabeln. Detta tillvägagångssätt anses vara mindre säkert men det är bekvämare och ett vanligt mönster med behållare.

Exempel

docker run \
...
-e TABLEAU_USERNAME=admin \
-e TABLEAU_PASSWORD=password \
-d <Tableau Server in a Container image ID or tag>

Konfigurera Tableau Server efter körning

När Tableau Server har initierats och körs är det bästa sättet att interagera med servern att använda TSM CLI-verktyget. Detta är det klassiska Tableau Server-verktyget för att utföra administrativa uppgifter. I framtiden kommer vi att stödja Tableau Server som reagerar på ändringar i den statiska konfigurationen i miljövariabeln CONFIG_FILE mellan körningarna. Men för närvarande, efter det att Tableau Server har initierats, måste du interagera med servern med de klassiska verktygen.

Mer information om TSM-kommandoraden finns i tsm-kommandoradsreferens.

Status

Det finns två grundläggande statuskontroller för Tableau Server i avbildningen. Dessa kan du använda för att kontrollera serverns livaktighet och beredskap.

Livaktighetskontroll

Livaktighetskontrollen indikerar om TSM-tjänster körs eller inte. Detta innebär att den indikerar om de orkestrerade tjänsterna för Tableau Server är aktiva och fungerar. Denna kontroll kan anropas här:

/docker/alive-check

Ett annat alternativ är att exponera port 8850 som Tableau Controller-tjänsten kör för att tillhandahålla administrativa funktioner via en webbläsare. Man skulle med jämna mellanrum kunna kontrollera tjänstens hälsa genom tcp-hälsokontroller.

Beredskapskontroll

Beredskapskontrollen indikerar om Tableau Server körs och om företagstjänster är redo att ta emot trafik. Detta kan fastställas med hjälp av följande skript:

/docker/server-ready-check

Ett annat alternativ är att använda tcp-hälsokontroller mot port 8080 (eller nåogn annan port som Tableau Server är bunden att ta emot trafik från). Ibland är den här typen av tcp-hälsokontroll mer tillförlitlig än server-ready-kontrollen, eftersom server-ready-konstrollen baseras på tjänststatus som rapporterats till TSM och som ibland kan försenas när tjänsttillståndet uppdateras.

Beständiga data

Med behållare vill vi ofta ha möjligheten att stänga en behållare och sedan slå på den igen utan att förlora någon viktig information. Avbildningar för Tableau Server i en container stöder detta så att du kan montera vissa kataloger utanför behållaren och helt kan förstöra eller ta bort behållarinstanser och änrå bevara dina data. Dessa data kan du använda för att starta en annan behållarinstans och återuppta där den tidigare behållaren slutade.

Följande avsnitt täcker de olika typerna av hanterade tillstånd.

Tableau Server-data

Serverdata lagras i datakatalogen. Datakatalogen är där alla användarrelaterade data och runtime-metadata lagras. Att externalisera dessa data innebär att din användares data kan bevaras även efter det att Tableau Server i en container har tagits bort helt och hållet.

Dessa data är överförbara och kan användas med molnhanterade blocklagringssystem, som AWS EBS-volymer.

När Tableau Server i en container används tillsammans med External Filestore måste datakatalogen finnas på EBS. Använd inte något nätverksfilsystem (exempelvis NFS) för datakatalogen. Det externa filarkivet kan finnas på en NFS-volym.

Statiska värdnamn

Tableau Server hanterar inte dynamiska värdnamnsändringar bra, så det är viktigt att specificera behållarens interna värdnamn så att det förblir konsekvent mellan behållarkörningar. Värdnamnet inuti en behållare är godtyckligt och kan ställas in på vilket värde som helst. Du kan ange behållarens interna värdnamn med alternativet --hostname. Se till att efterföljande behållare som använder samma beständiga data körs med samma värdnamnsvärde.

Detta ska inte förväxlas med serverinstallationer med flera noder. I dessa bör ytterligare noder var och en tilldelas ett annat värdnamn. Det som spelar roll är att när en enskild behållare startas om måste den ersättande behållaren som kommer att använda samma beständiga data för den instansen ha ett matchande värdnamn.

Fullständigt exempel

Här är ett exempel där datakatalogen är monterad utanför behållaren.

docker run \
-v <empty-data-dir>:/var/opt/tableau \
-e LICENSE_KEY=<key> \
--hostname=<static (internal) name of host machine> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Säkerhetskopiering och återställning

Tableau Server i en container stöder Tableau Server som skapar säkerhetskopior och återställer från en backupfil (.tsbak). Det första steget är att köra en Tableau Server i en container-avbildning, ha backupfilen (.tsbak) monterad i avbildningen och ställa in miljövariabeln BACKUP_FILE med sökvägen till säkerhetskopieringsfilen. Dessutom måste du tillhandahålla backup json-konfigurationsfilen i miljövariabeln CONFIG_FILE. Tableau Server-behållaren automatiserar återställningsprocessen även för driftsättningar med flera noder. Om denna automatisering vid något tillfälle inte lyckas återställa systemet helt, kan du alltid använda de klassiska Tableau Server-verktygen och processerna som TSM-kommandon för att interagera med Tableau Server på samma sätt som du skulle göra med en driftsättning utan behållare.

Mer information om hur du kan säkerhetskopiera och återställa en Tableau Server-standardinstans finns i Utför en fullständig säkerhetskopiering och återställning av Tableau Server..

Säkerhetskopiering i Tableau Server-behållare

1. Öppna skalet i version A av Tableau Server i en container. Skapa säkerhetskopieringsfiler för lagringsplats, topologi och konfiguration.

   docker exec -it my-server bash
   
   # Just providing filename automatically produces the backup file at /var/opt/tableau/tableau_server/data/tabsvc/files/backups/
   tsm maintenance backup -f <repository-backup>.tsbak -d
   
   # Any filepath where current user(UNPRIVILEGED USER) can write.
   tsm settings export -f /var/opt/tableau/tableau_server/data/tabsvc/files/backups/<topology-conf-backup>.json

2. Kopiera filerna som skapades i föregående steg till värddatorn. Ändra filbehörigheten till att ha läs allt-behörighet inställt för båda filerna.

   docker cp my-server:/var/opt/tableau/tableau_server/data/tabsvc/files/backups/<repository-backup>.tsbak ./<repository-backup>.tsbak
   docker cp my-server:/var/opt/tableau/tableau_server/data/tabsvc/files/backups/<topology-conf-backup>.json ./<topology-conf-backup>.json
   chmod a+r ./<repository-backup>.tsbak ./<topology-conf-backup>.json

3. Förvara säkerhetskopieringsartefakter på en säker plats. Följ återställningsstegen nedan när så behövs.

Återställa i Tableau Server-behållare

Säkerhetskopior från alla Tableau Server-versioner som stöds (behållare och ej behållare) kan återställas i Tableau Server-behållaren.

Förutsättningar

• Tableau Server-säkerhetskopieringsfil.
  
• En json-konfigurationsfil som innehåller både konfigurations- och topologiinformation.
• json-fil för konfiguration som innehåller information om identitetslagring.
• Obs! Du kommer sannolikt att behöva ändra säkerhetskopiorna så att de har läs allt-behörighet. Säkerhetskopieringsfiler är vanligtvis låsta till användaren som skapade filen, och den här kommer sannolikt att vara annorlunda än Tableau-användaren som körs i behållaren.

docker run \
-v <full-path-to-backup-file>:/docker/config/backup/backup-file.tsbak \
-v <full-path-to-config-only-file>:/docker/config/config.json:ro \
-v <full-path-to-identity-store-config-only-file>:/docker/config/identity-store-config.json \
-e LICENSE_KEY=<key> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Obs!

• Om du återställer ett system med flera noder måste du också starta de andra noderna om återställningsautomatiseringen ska fungera. Mer information finns i avsnittet Tableau Server i en container med flera noder i det här dokumentet. Endast den initiala noden kräver säkerhetskopieringsfilen, säkerhetskopieringskonfigurationsfilen och licensen.
• Säkerhetskopieringsfilerna behöver bara tillhandahållas i den första körningen av behållaren. När servern väl har initierats behöver du inte fortsätta monteringen i säkerhetskopieringsfilerna.

Migrera från Tableau Server till Tableau Server i en container

Om du vill migrera från en Tableau Server-standardinstallation till Tableau Server i en container måste du säkerhetskopiera och återställa. Säkerhetskopior från alla Tableau Server-versioner som stöds (behållare och ej behållare) kan återställas i Tableau Server-behållaren. Mer information finns i avsnittet Återställa i Tableau Server-behållare ovan.

Uppgradering av Tableau Server-versioner

Det finns två sätt att uppgradera Tableau Server. Metoden för att uppgradera avbildning som listas i det här avsnittet är den rekommenderade lösningen. Men en alternativ metod är att uppgradera Tableau Server med Säkerhetskopiera/återställa.

Uppgradera med metoden Uppgradera avbildning

Den uppgraderade avbildningen är en Docker-avbildning som kan byggas med skriptet build-upgrade-image från konfigurationsverktyget för Tableau Server i en container. Syftet med avbildningen är enbart att uppgradera den Tableau Server i en container som körs för närvarande.

Uppgradera genom att följa stegen nedan.

1. Skapa en uppgraderingsavbildning med skriptet build-upgrade-image. Den nya versionens Tableau Server RPM behövs för att bygga denna behållare.
2. Stäng den behållare som för närvarande kör Tableau Server.
3. Starta uppgraderingsavbildningen, montera samma datakatalog från den stängda behållaren i föregående steg.
4. Uppgraderingsprocessen tar ett tag, men Tableau Server kommer att uppgraderas. Kontrollera Docker-loggarna om du vill ha en uppdatering av uppgraderingsprocessen. Behållaren stängs av efter uppgraderingsprocessen.
5. Starta en ny Tableau Server i en container i en nyare version. Montera katalogen från föregående steg.

Exempel:

Låt oss säga att vi har en Tableau Server i en container som kör Tableau Server. Här är några antaganden i det här exemplet:

• Jag har värdefulla data och jag vill inte förlora några data under uppgraderingsprocessen. Datakatalogen måste finnas kvar utanför behållaren.
• Behållaren heter min-server. Docker-avbildningen heter tableau-server:version A.
• Serverversionen som min-server använder för närvarande är version A.
• Serverversionen jag vill uppgradera till är version B.

1. Hämta Tableau Server rpm för version B. Skapa en uppgraderingsbild.

   # For all the options available in the script
   ./build-upgrade-image -h
    
   # Frequently used command to create a upgrade-image
   ./build-upgrade-image --installer=<path to the tableau server version B> -i tableau-server:versionA -o tableau-server-upgrade:versionAB

2. Stoppa min-server-behållaren.

   docker stop my-server -t 120

3. Starta den nyskapade avbildningen tableau-server-upgrade:versionAB. Montera samma datakatalog från den tidigare stoppade behållaren. Behållaren startar uppgraderingsprocessen till version B.

   docker run --name my-upgrade-server \
   -v <data-dir mount from previous step>:/var/opt/tableau \
   ...
   tableau-server-upgrade:versionAB

4. Behållaren stoppas när uppgraderingen är klar. Kontrollera uppgraderingsprocessloggarna i Docker-loggarna och verifiera att uppgraderingsprocessen har lyckats. Du kan också kontrollera Docker-behållarens utgångskod om du vill verifiera att uppgraderingsprocessen har slutförts korrekt.

   # The log file /var/opt/tableau/tableau_server/logs/upgrade-console.log is created after 3-4 mins into the start of upgrade container. When the upgrade completes successfully, "upgrade is complete" log will be # seen.
   docker logs my-upgrade-server
   ...
   ...
   Verifying licensing state.
   Tableau Server has been upgraded to version near.20.0801.1050.
   >> The upgraded Tableau binary directory will be added to PATH for new shells. To get the
   >> updated path, either start a new session, or for bash users run:
   >> source /etc/profile.d/tableau_server.sh
   Starting service...
   Starting service...
   Job id is '12', timeout is 30 minutes.
   Service was started successfully.
   Status: RUNNING
   Tableau Server is Running
   upgrade is complete

5. Stoppa my-upgrade-server-behållaren. Starta den nya versionen B av Tableau Server i en behållaravbildning och montera datakatalogen från den stoppade my-upgrade-server-behållaren

   # Stop the server.
   docker stop my-upgrade-server -t 120
   
   
   # Run the new version Hu
   docker run --name my-upgraded-server \
   -v <data-dir mount from previous step>:/var/opt/tableau \
   ...
   ...
   tableau-server:versionB

Uppgradera genom att säkerhetskopiera och återställa

Följ stegen i avsnittet Återställa och säkerhetskopiera i det här dokumentet. Den enda justering du behöver göra för att ändra en säkerhetskopierings-/återställningsåtgärd till en uppgraderingsåtgärd är att återställa säkerhetskopian i en ny version av Tableau Server.

Tableau Server i en container med flera noder

Med Tableau Server i en container med flera noder avses en enda driftsättning av Tableau Server fördelad över flera noder. Flera noder i detta sammanhang är detsamma som Tableau Server med flera noder där vissa processer kan köras på andra noder för att öka kapaciteten, beräkningskraften etc. Detta skiljer sig från de fall där man startar flera individuella Tableau Server i en container och där varje behållare är en oberoende server med sina egna distinkta data.

Tableau Server i en container med flera noder fungerar ungefär som en Tableau Server med flera noder utan behållare, och använder samma underliggande mekanism. En översikt över hur du kan konfigurera en installation av Tableau Server med flera noder utan behållare finns i Distribuerade och högtillgängliga Tableau Server-installationer.

Här är ett exempel:

Grundläggande användning med flera noder

Ursprunglig nod

Alternativ 1: Använd detta om serverkonfigurationen (CONFIG_FILE) föreskriver en topologi med flera noder:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-v <full-path-to-config-file>:/docker/config/config.json:ro \
-e LICENSE_KEY=<key> \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \
--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Alternativ 2: Använd detta om du vill ha en konfiguration med flera noder även om serverkonfigurationen inte föreskriver en topologi med flera noder:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e LICENSE_KEY=<key> -e ALWAYS_WRITE_BOOTSTRAP_FILE=1 \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \

--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Ytterligare nod

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e BOOTSTRAP_INSTALL=1 \
-p 8080:8080 -p 8800-9000:8800-9000 \
--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Exponera licensiering och TSM-portar

Om arbetarnoder ska kunna kommunicera med den primära instansen måste du öppna ytterligare portar. Du måste tillåta trafik från andra noder på din primära Tableau Server i en container-instans i följande portintervall:

Service Ports: 8800-9000
Postgres Port: 8060
Licensing Ports: 27000-27010

Var försiktig med hur många portar du öppnar: Vi rekommenderar att du endast exponerar 200 portar, 8800-9000, istället för Tableau Servers standardportintervall på 8000-9000, eftersom exponering av 1000 portar i Docker kan påverka Docker-avbildningens prestanda och starttid negativt. Du kan använda ett mindre eller större portintervall beroende på hur komplex din Tableau Server-topologi är. Generellt rekommenderar vi inte exponering av färre än 100 portar, eftersom du i annat fall riskerar du att tjänster i ett kluster inte kan kommunicera med vissa tjänster. Om du anger ditt eget portintervall, så var noga med att exponera port 8850 (som ju ingår implicit i 8800-9000). Du specificerar portintervallet genom att ställa in miljövariablerna PORT_RANGE_MIN och PORT_RANGE_MAX.

Ytterligare noder kommer också att behöva exponera Service Port-intervallet (8800-9000), men inte Licensing Port-intervallet. Det är viktigt att notera att dessa portintervall endast är till för att tillåta Tableau Server-kommunikation mellan processer. Dessa portar bör inte exponeras för användare eller andra maskiner än datorer som kör Tableau Server i en container för samma flernodskluster.

Dessa portregler överensstämmer med Tableau Server-brandväggsdokumentationen. Mer information finns i Konfigurera en lokal brandvägg.

Lösa värdnamn

De många noderna för Tableau Server i en container måste köras med konsekventa värdnamn eftersom Tableau Server inte kan hantera dynamiska värdnamnsändringar. När du kör Tableau Server med flera noder, kommer dessa noder att vilja kommunicera med varandra. Tableau Server-noderna kommer att försöka nå varandra med de värdnamn som Tableau Server med flera noder i en behållare har konfigurerats till att använda. Om du exempelvis kör din initiala nod med värdnamnet ”initial” kommer ytterligare noder att försöka skicka trafik till en värd som heter ”initial”. Det finns flera sätt du kan konfigurera avbildningar på för att lösa värdnamn för andra avbildningar. /etc/hosts-filen i varje behållare för att mappa det godtyckliga behållarens värdnamn (dvs ”initial”) till IP-adressen som faktiskt kör den andra behållaren.

Starta ytterligare noder

Den initiala Tableau Server-behållaren som körs som en del av ett kluster genererar en startfil som efterföljande ytterligare noder behöver använda för att gå med i klustret. Efter det att ytterligare noder har registrerats i klustrets topologi kan du börja tilldela Tableau Server-processer att köras på dem. Denna process kan automatiseras helt. Om du har angett en konfigurationsfil för Tableau Server (som man vanligen anger genom att montera en konfigurationsfil på filsökvägen specificerad av CONFIG_FILE, standardsökväg: /docker/config/config.json) som anger en topologi med flera noder, kommer den initiala noden automatiskt att vänta tills alla ytterligare noder har registrerats. När den väl har registrerats kommer topologin med flera noder att tillämpas på hela klustret.

När den initiala noden i Tableau Server i en container kör Tableau Server fullt ut kan du få den att generera en startfil för ytterligare noder:

docker exec -it <container-name> tsm topology nodes get-bootstrap-file -f $BOOTSTRAP_FILE

Detta kommando anropas automatiskt för dig om du ställer in värdet för ALWAYS_WRITE_BOOTSTRAP_FILE på 1.

Säkerhetsöverväganden

Startfilen innehåller serverhemligheter som gör att den kan upprätta en TSM-session med den initiala noden. Detta innebär att om användare med skadligt uppsåt skaffar filen kan de skicka TSM-kommandon till servern under en viss tidsperiod. Själva filen innehåller också data som kan möjliggöra dekryptering av serverkonfigurationshemligheter. Denna fil bör behandlas som känslig och bör endast vara tillgänglig för tjänster och system som är direkt relaterade till att etablera en driftsättning med flera noder.

Startfilens förfallotid

Startfiler har en tidsbegränsad session som varar i 2 timmar. Inom den tidsramen behöver de extra noderna inte ange referenser till den initiala noden för att ansluta som en extra nod. Det är möjligt att använda en startfil när sessionen har löpt ut, men det skulle innebära att du måste ange referenser till den initiala noden.

Överföring av startfilen

Startfilen måste göras tillgänglig för och konsumeras av arbetarnodernas Tableau Server i en container. Startfilen måste delas med alla andra noders Tableau Server i en container som du vill använda som arbetarnoder för den här distributionen. Detta kan du göra på många olika sätt.

Överför filen över ett säkert nätverk

En del av automatiseringen på den initiala noden kan innebära att filen skickas direkt till ytterligare noder. Detta bör göras med hjälp av någon säker filöverföringsklient/verktyg. Detta är förmodligen mer användbart i scenarier där flera startfiler kan genereras under den initiala nodens livslängd (möjligen för att lägga till fler ytterligare noder vid ett senare tillfälle).

Använd en nätverksfilmontering

En nätverksfilmontering som delas av alla behållare i en given driftsättning är ett annat alternativ.

Annat

Slutmålet är att säkert överföra en fil som producerats av en behållare och överföra den till en specifik uppsättning med andra behållare. Så varje metod som uppnår detta och är säker är tillräcklig.

Starta ytterligare noder

Om du vill starta ytterligare en nod för en Tableau-server i en behållare startar du helt enkelt behållaren med miljövariabeln BOOTSTRAP_INSTALL inställd på 1.

Detta uppmanar instansen av Tableau Server i en container att vila tills en startfil finns på den sökväg som specificeras av miljövariabeln BOOTSTRAP_FILE (som även är konfigurerbar). Du kan se standardfilsökvägen i miljövariabeltabellen. Om du, för att förtydliga, kör en avbildning av Tableau Server i en container i ”extra nödläge” kommer behållaren inte att starta supervisord eller någon annan process än ett bash-skript som körs som pid 1 och kontrollerar var 5:e sekund om startfilen finns . Så snart filen är närvarande fortsätter Tableau Server i en container att initialiseras som en extra nod.

Konfigurera ytterligare noder

Att konfigurera ytterligare noder för att köra en specifik topologi fungerar på samma sätt som i en normal Tableau Server-driftsättning. Det medför även samma krav, vilket innebär att om du lägger till nya processer på en nod kan du behöve starta om hela klustret. Mer information finns i Konfigurera noder.

Överväganden om funktioner i Tableau Server

Vissa Tableau Server-funktioner fungerar annorlunda i behållare. Det här avsnittet handlar om specifika funktioner som kräver särskilda eller annorlunda överväganden i en behållarmiljö.

Active Directory

Ange AD-domänkontrollant

Om du planerar att använda Active Directory som ett identitetsregister för Tableau Server-webbsidor och webbplatser finns det ytterligare en sak att ta hänsyn till. Tableau Server som körs i Linux-miljöer avgör dynamiskt vilken Ad-domänkontrollant den kommunicerar med genom att undersöka dess IP-undernät. Containers kan tilldelas godtyckliga IP-adresser och i det här fallet kommer Tableau Server inte nödvändigtvis kunna använda sin IP-adress för att hitta en lämplig domänkontrollant. Därför kan det vara nödvändigt att konfigurera en specifik domänkontrollant eller ett specifikt värdnamn som Tableau Server ska kommunicera med. Gör detta genom att följa dessa steg:

1. Ta reda på vilken domänkontrollant du vill att Tableau Server ska använda och hämta värdnamnet.

2. Ange konfigurationsnyckeln wgserver.domain.ldap.hostname till värdnamnet med standardkonfigurationsalternativen för Tableau Server Admin:

   • Ange värdet i json-konfigurationsfilen CONFIG_FILE.

   • Använd TSM-konfigurationskommandot

     tsm configuration set -k wgserver.domain.ldap.hostname -v <hostname>

Importera AD-certifikat till Tableau Server-nyckelarkiv

Som standard kommunicerar Tableau Server i en container med AD via StartTLS när enkel bindning används. När behållaren körs i den här konfigurationen måste du alltså importera AD-servercertifikatet till Tableau Server-nyckelarkiv, annars misslyckas serverinitieringen. Gör detta genom att följa dessa steg:

1. Skapa ett pre-init-command-skript (se avsnittet om skript inför initiering). Lägg till följande rad för att lägga till AD-certifikatet i Tableau Server-nyckelarkiv.

   ${INSTALL_DIR}/packages/repository.${SERVICE_VERSION}/jre/bin -importcert -noprompt -alias startTlsCert -file <mounted-certificate-path> -storetype JKS -storepass changeit -keystore ${DATA_DIR}/config/tableauservicesmanagerca.jks

2. Installera AD-servercertifikatet på den filsökväg som anges för parametern -file i skriptet pre-init-command.

Ett alternativ är att inaktivera standardinställningen för kommunikation med AD via StartTLS. Ställ in wgserver.domain.ldap.starttls.enabled som false så inaktiveras StartTLS. Detta rekommenderas dock inte.

Exempel på konfiguration för driftsättning

Docker

Grundläggande användning av Tableau Server i en container

docker run \
-e LICENSE_KEY=<key>
-p 8080:8080
-d <Tableau Server in a Container image ID or tag>

Grundläggande användning av Tableau Server i en container med automatisk första administratörsanvändare

docker run \
-e LICENSE_KEY=<key> \
-e TABLEAU_USERNAME=<myadmin> \
-e TABLEAU_PASSWORD_FILE=/etc/tableau-admin-secret \
-v <full-path-to-pw-file>:/etc/tableau-admin-secret \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Endast TSM-läge

docker run \
-e TSM_ONLY=1 \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Grundläggande användning med flera noder

Ursprunglig nod

Alternativ 1: Använd detta om serverkonfigurationen (CONFIG_FILE) föreskriver en topologi med flera noder:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-v <full-path-to-config-file>:/docker/config/config.json:ro \
-e LICENSE_KEY=<key> \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \
--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Alternativ 2: Använd detta om du vill ha en konfiguration med flera noder även om serverkonfigurationen inte föreskriver en topologi med flera noder:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e LICENSE_KEY=<key> -e ALWAYS_WRITE_BOOTSTRAP_FILE=1 \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \
--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Ytterligare nod

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e BOOTSTRAP_INSTALL=1 \
-p 8080:8080 -p 8800-9000:8800-9000 \
--hostname=<static (internal) name of host machine> \
-d <Tableau Server in a Container image ID or tag>

Externalisera dataanvändningen

docker run \
-v <empty-data-dir>:/var/opt/tableau \
-e LICENSE_KEY=<key> \
--hostname=<static (internal) name of host machine> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Grundläggande användning av Init-container

Init-behållare

docker run \
-v <empty-data-dir>:/var/opt/tableau \
-e LICENSE_KEY=<key> \
-e INIT_CONTAINER=1 \
--hostname=<static (internal) name of host machine> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Körningsbehållare

docker run \
-v <empty-data-dir>:/var/opt/tableau \
--hostname=<static (internal) name of host machine> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Grundläggande återställning från enkel säkerhetskopieringsnod

docker run \
-v <full-path-to-backup-file>:/docker/config/backup/backup-file.tsbak \
-v <full-path-to-config-only-file>:/docker/config/config.json:ro \
-e LICENSE_KEY=<key> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Docker – Compose

version: '3.2'
services:
    tableau-server:
         hostname: localhost
         volumes:
              - <your-tsm-command-file>:/docker/config/tsm-commands:ro
              - <your-config-file >:/docker/config/config.json:ro
         ports:
              - "8080:8080"
         image: ${IMAGE_NAME}
         environment:
              - LICENSE_KEY=<license-key>