ความช่วยเหลือ Tableau Server บน Linux

ข้อจำกัดของ Tableau Server ในคอนเทนเนอร์

• Tableau Server ในคอนเทนเนอร์รองรับเฉพาะการเปิดใช้งานใบอนุญาตโดยใช้ Server ATR เท่านั้น รองรับการเปิดใช้งานแบบออฟไลน์โดยใช้ Server ATR ในเวอร์ชัน 2023.1 และใหม่กว่า ฟังก์ชันนี้พร้อมให้ใช้งานในคอนเทนเนอร์ แต่ต้องมีขั้นตอนและการอนุมัติเพิ่มเติม หากคุณต้องการเรียกใช้ Tableau Server ในคอนเทนเนอร์ในสภาพแวดล้อมแบบตัดขาดจากระบบเครือข่ายหรือออฟไลน์ โปรดติดต่อตัวแทนบัญชีของคุณเพื่อขอข้อมูลเพิ่มเติม
• ปัจจุบัน Tableau Server ในคอนเทนเนอร์ไม่รองรับเอเจนต์ของ Resource Monitoring Tool (RMT)
• Tableau Server ในคอนเทนเนอร์ไม่รองรับ Kerberos

อิมเมจ Tableau Server ในคอนเทนเนอร์

อิมเมจ Tableau Server ในคอนเทนเนอร์คืออิมเมจของ Docker ที่มี Tableau Server ทั้งหมด ระบบจะสร้างอิมเมจขึ้นโดยใช้ Tableau Server ในเครื่องมือการตั้งค่าคอนเทนเนอร์ เมื่อสร้างแล้ว อิมเมจจะรวม Tableau Server ไว้ด้วย แต่ยังไม่ได้เริ่มต้น ผู้ใช้ตามค่าเริ่มต้นในอิมเมจ Tableau Server ในคอนเทนเนอร์คือผู้ใช้ที่ไม่มีสิทธิ์รูท

ข้อกำหนดเบื้องต้น

เรียกใช้สคริปต์ configure-container-host

เมื่อติดตั้ง Tableau Server โดยไม่มีคอนเทนเนอร์ จะมีการเปลี่ยนแปลงข้อจำกัดบางอย่างด้านทรัพยากรและพร็อพเพอร์ตี้ Coredump โดยเป็นส่วนหนึ่งในกระบวนการติดตั้ง ซึ่งจะช่วยปรับปรุงประสิทธิภาพของ Tableau Server อิมเมจ Tableau Server ในคอนเทนเนอร์ไม่มีความสามารถในการเปลี่ยนแปลงเครื่องโฮสต์ ดังนั้นเราจึงแนะนำให้เรียกสคริปต์ configure-container-host ที่ให้มากับ Tableau Server ในเครื่องมือการตั้งค่าคอนเทนเนอร์บนเครื่องที่จะทำงานกับอิมเมจ Tableau Server ในคอนเทนเนอร์ สคริปต์นี้จะรับรองประสิทธิภาพของอิมเมจ Tableau Server ในคอนเทนเนอร์ว่าเทียบเท่ากับแบบที่ไม่ใช้คอนเทนเนอร์

วิธีการเรียกใช้สคริปต์ configure-container-host:

1. ค้นหาสคริปต์ (configure-container-host) ในไดเรกทอรีระดับสูงสุดของ Tableau Server ในเครื่องมือการตั้งค่าคอนเทนเนอร์

2. คัดลอกสคริปต์ไปยังสภาพแวดล้อมที่คุณวางแผนจะใช้งาน Tableau Server

3. กำหนดบัญชีผู้ใช้/UID ที่ไม่มีสิทธิ์ ที่จะใช้เป็นผู้ใช้ตามค่าเริ่มต้นของอิมเมจ Tableau Server ในคอนเทนเนอร์ ผู้ใช้รายนี้ควรอยู่บนเครื่องโฮสต์ และควรตรงกับ UID ที่ตั้งในตัวแปรสภาพแวดล้อม UNPRIVILEGED_TABLEAU_UID ของคอนเทนเนอร์ Tableau Server หากคุณไม่ได้ตั้งผู้ใช้เอาไว้เมื่อสร้างอิมเมจ Docker ระบบจะกำหนด ID ของผู้ใช้ที่ไม่มีสิทธิ์ตามค่าเริ่มต้นภายในคอนเทนเนอร์เป็น 999 หากคุณใช้การแมปผู้ใช้ของ Docker คุณควรกำหนด UID นี้ให้เกี่ยวข้องกับผู้ใช้ที่มีอยู่ในเครื่องโฮสต์

4. ใช้สคริปต์ด้วยสิทธิ์รูท ดังนี้

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

การเรียกใช้อิมเมจ

หากต้องการใช้ Docker อิมเมจของ Tableau Server ในคอนเทนเนอร์ คำสั่งที่ง่ายที่สุดที่จะเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์มีดังนี้

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

ขั้นตอนนี้จะเรียกใช้ Docker ในเบื้องหลังและหลังจากนั้นครู่หนึ่ง จะส่งผลให้อินสแตนซ์ของ Tableau Server ติดตั้งอย่างสมบูรณ์ Tableau Server อาจใช้เวลาเริ่ม 10 ถึง 20 นาที ขึ้นอยู่กับฮาร์ดแวร์ของคอมพิวเตอร์ที่เรียกใช้อิมเมจ คุณสามารถยืนยันว่าคอนเทนเนอร์กำลังทำงานได้โดยพิมพ์คำสั่ง docker ps เมื่อ Tableau Server ทำงาน คุณจะต้องสร้างบัญชีผู้ดูแลระบบ Tableau Server เริ่มต้น ขั้นตอนนี้อาจดำเนินการอัตโนมัติ หากต้องการข้อมูลเพิ่มเติม โปรดดูสร้างผู้ดูแลระบบ Tableau Server คนแรกโดยอัตโนมัติ

สรุปอาร์กิวเมนต์การเรียกใช้ขั้นพื้นฐาน

ตัวเลือกทั้งหมดที่ใช้ในคำสั่งการเรียกใช้ Docker ล้วนเป็นตัวเลือกที่จำเป็น และบ่อยครั้งก็จะมีตัวเลือกเพิ่มเติมเพื่อประโยชน์ในการใช้ฟังก์ชันการทำงานต่างๆ ในภาพ สำหรับตอนนี้ เราจะดูเฉพาะอาร์กิวเมนต์ที่ใช้ในคำสั่งเรียกใช้ Docker ที่ง่ายที่สุดสำหรับ Tableau Server ในคอนเทนเนอร์:

สร้างผู้ดูแลระบบ Tableau Server คนแรกโดยอัตโนมัติ

เมื่อเริ่มต้นใช้งาน Tableau Server เป็นครั้งแรก จะต้องสร้างผู้ใช้ที่เป็นผู้ดูแลระบบเริ่มต้นขึ้นก่อนจึงจะอนุญาตการเชื่อมต่อเครือข่ายทางไกลเข้ากับ Tableau Server ซึ่งสามารถทำได้โดยเรียกใช้คำสั่ง tabcmd initialuser -s localhost:8080 -u <username> -p <password> ภายในคอนเทนเนอร์ คุณสามารถตั้งค่าข้อมูลประจำตัวของผู้ดูแลระบบผ่านตัวแปรสภาพแวดล้อมได้ด้วย TABLEAU_USERNAME และ TABLEAU_PASSWORD หรือ TABLEAU_PASSWORD_FILE (แนะนำ) คือตัวแปรสภาพแวดล้อมที่สามารถตั้งค่าให้ส่งผ่านข้อมูลเข้าสู่ระบบของผู้ดูแลระบบเริ่มต้นได้ หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการจัดการรหัสผ่าน โปรดดู การจัดการรหัสผ่าน

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับคำสั่ง tabcmd initialuser โปรดดู initialuser

ตัวอย่าง

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>

การให้สิทธิ์อนุญาต

การให้สิทธิ์อนุญาตในคอนเทนเนอร์

การให้สิทธิ์อนุญาต Tableau Server ในคอนเทนเนอร์จะใช้บริการให้สิทธิ์เรียกใช้ (ATR) ของเซิร์ฟเวอร์เพื่อเปิดใช้งาน Tableau Server ที่ปรับใช้ในระบบคลาวด์ หรือสภาพแวดล้อมเสมือน โดยไม่ต้องเรียกใช้การปิดใช้งานสิทธิ์อนุญาต บริการ ATR สามารถทำขั้นตอนนี้ได้โดยให้สัญญาเช่าระยะสั้นของระยะเวลาที่กำหนดได้ (ระยะเวลา ATR) จนกว่าจะถึงวันหมดอายุของคีย์ผลิตภัณฑ์ ATR จะสรุปการให้สิทธิ์อนุญาตของ Tableau จากการเปลี่ยนแปลงฮาร์ดแวร์เบื้องหลัง ซึ่งเป็นแง่มุมพื้นฐานของการปรับใช้คอนเทนเนอร์ เนื่องจาก ATR ของเซิร์ฟเวอร์กำหนดให้คอนเทนเนอร์ต้องเข้าถึงบริการ ATR ที่ Tableau โฮสต์ได้ ดังนั้นคอนเทนเนอร์จึงจำเป็นต้องเชื่อมต่ออินเทอร์เน็ต Tableau Server ในคอนเทนเนอร์ไม่รองรับการเปิดใช้งานแบบออฟไลน์หรือด้วยตนเอง หากต้องการข้อมูลเพิ่มเติม โปรดดู เปิดใช้งาน Tableau Server ด้วยบริการให้สิทธิ์การใช้งาน (Authorization-To-Run (ATR))

สำคัญ: คุณต้องระบุตัวแปรสภาพแวดล้อม LICENSE_KEY หรือ LICENSE_KEY_FILE (เพียงชุดเดียว)

เมื่ออัปเกรด Tableau Server ในคอนเทนเนอร์ หากคุณมีจำนวนสิทธิ์อนุญาตจนถึงขีดจำกัดสูงสุดแล้ว Tableau Server จะไม่สามารถเริ่มได้จนกว่าระยะเวลา ATR จะผ่านไป (4 ชั่วโมง/14400 วินาทีตามค่าเริ่มต้น) หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าหรือเปลี่ยนแปลงระยะเวลา ATR โปรดดู เปิดใช้งาน Tableau Server ด้วยบริการให้สิทธิ์การใช้งาน (Authorization-To-Run (ATR))(ลิงก์จะเปิดในหน้าต่างใหม่)

ตัวแปรสภาพแวดล้อมการให้สิทธิ์อนุญาต

Tableau Server ในคอนเทนเนอร์รองรับการตั้งค่าคีย์ใบอนุญาตโดยใช้ตัวแปรสภาพแวดล้อม โดย LICENSE_KEY จะมีคีย์ได้ตั้งแต่หนึ่งคีย์ขึ้นไป (-e LICENSE_KEY="<key1> , <key2>") โดยใช้เครื่องหมายจุลภาคคั่นในรายการ

ตัวอย่าง

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

ไฟล์สิทธิ์อนุญาต

Tableau Server ในคอนเทนเนอร์รองรับการตั้งค่าคีย์ผลิตภัณฑ์โดยใช้ไฟล์ด้วยเช่นกัน ต่อเชื่อมไฟล์กับตำแหน่งไฟล์คีย์สิทธิ์อนุญาตตามค่าเริ่มต้นในคอนเทนเนอร์ (/docker/config/license_file) หรือตามที่ระบุโดยตัวแปรสภาพแวดล้อม LICENSE_KEY_FILE

ตัวอย่าง

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>

ระยะเวลาการเช่าสิทธิ์อนุญาตที่ร้องขอ

คุณสามารถระบุเวลาการเช่าสิทธิ์อนุญาต ATR ในคอนเทนเนอร์ Tableau Server ได้ โดยการตั้งค่าตัวแปรสภาพแวดล้อม REQUESTED_LEASE_TIME คุณต้องระบุเวลาการเช่าเป็นวินาที โดยระยะเวลาขั้นต่ำคือ 3600 วินาที (หรือ 1 ชั่วโมง) ขอแนะนำให้คุณลดเวลาการเช่าลงเมื่อทำการทดลองและทดสอบ Tableau Server เพื่อลดโอกาสที่จะถึงขีดจำกัดสูงสุดของการเช่าที่เปิดใช้งาน สำหรับการปรับใช้ในสภาพแวดล้อมจริง ขอแนะนำเป็นอย่างยิ่งว่าไม่ควรกำหนดพารามิเตอร์ REQUESTED_LEASE_TIME (ใช้เป็นค่าเริ่มต้น) เพื่อให้ Tableau สามารถกำหนดเวลาการเช่าที่เหมาะสมได้

ตัวอย่าง

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

การเรียกใช้อิมเมจที่ยังไม่ได้เริ่ม

Tableau Server มีการติดตั้งสองระยะ ระยะแรกคือการติดตั้ง Tableau Service Manager (TSM) สำหรับในการติดตั้งแบบในองค์กรโดยทั่วไป ขั้นตอนนี้เป็นเวลาที่ผู้ดูแลระบบเซิร์ฟเวอร์จะลงทะเบียนเซิร์ฟเวอร์ เปิดใช้งานใบอนุญาต และกำหนดค่าเซิร์ฟเวอร์ให้ทำงานตามที่ต้องการ ระยะที่สองของการติดตั้งคือการตั้งค่าและเริ่มต้นกระบวนการ Tableau Server ซึ่งจะจัดการการรับส่งข้อมูลของผู้ใช้ปลายทางและตรรกะทางธุรกิจที่เกี่ยวข้อง

พฤติกรรมตามค่าเริ่มต้นของอิมเมจ Tableau Server ในคอนเทนเนอร์จะดำเนินขั้นตอนติดตั้งทั้งหมดโดยอัตโนมัติ ดังนั้นคำสั่ง docker run ก็จะส่งผลให้เซิร์ฟเวอร์ทำงานได้อย่างสมบูรณ์ในที่สุด อย่างไรก็ตาม หากคุณต้องการเริ่มอิมเมจ Tableau Server ในคอนเทนเนอร์ และให้ทำงานเฉพาะบริการ TSM เท่านั้น (สิ่งที่ผู้ดูแลระบบเซิร์ฟเวอร์คาดหวังหากเพิ่งเรียกใช้คำสั่ง initialize-tsm) คุณจะสามารถทำได้โดยส่งผ่านแฟล็ก TSM_ONLY เป็นตัวแปรสภาพแวดล้อม

ตัวอย่าง:

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

การโต้ตอบกับอิมเมจ

เมื่อคุณเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์แล้ว คุณจะสามารถเรียก TSM และใช้คำสั่ง tabcmd ได้โดยตรง โดยเครื่องมือเหล่านี้จะเพิ่มลงในเส้นทางสภาพแวดล้อมโดยตรงของผู้ใช้ pid 1 ราย (ซึ่งได้รับสิทธิ์รูทในขณะนี้) จึงหมายความว่า คุณสามารถเรียก TSM และคำสั่ง tabcmd ได้ดังนี้

docker exec -it <container> tsm status -v

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

และยังสามารถเปิดเชลล์ในคอนเทนเนอร์เพื่อดำเนินการงานทั่วไปได้มากขึ้น เราไม่แนะนำขั้นตอนนี้ในสถานการณ์ทั่วไป ยกเว้นเพื่อจุดประสงค์ในการแก้ไขข้อบกพร่อง

docker exec -it <container> bash

TSM Web UI และ CLI ทางไกล

TSM Web UI และ CLI ทางไกลจะไม่สามารถเข้าถึงได้ตามค่าเริ่มต้น เนื่องจากต้องใช้ชื่อผู้ใช้และรหัสผ่านเพื่อตรวจสอบสิทธิ์ และโดยค่าเริ่มต้น ผู้ใช้ที่เรียกใช้กระบวนการ Tableau Server ในคอนเทนเนอร์จะไม่ได้รับรหัสผ่าน ระบบดำเนินการนี้เพื่อเหตุผลด้านความปลอดภัย (เราไม่แนะนำให้ส่งอิมเมจที่มีรหัสผ่านตามค่าเริ่มต้นอยู่ภายใน เนื่องจากจะอนุญาตให้สามารถเข้าถึงจากระยะไกลได้) ในบางกรณี TSM Web UI และการเรียกการเข้าถึงจากระยะไกลโดยใช้ TSM CLI อาจมีประโยชน์ หากคุณต้องการใช้ฟีเจอร์เหล่านี้ คุณจะต้องทำตามขั้นตอนที่ระบุด้านล่างเพื่อสร้างบัญชีผู้ใช้ที่สามารถเข้าถึงจากระยะไกล

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับ TSM Web UI และ CLI โปรดดูเข้าสู่ระบบ Tableau Services Manager Web UI

การสร้างผู้ใช้ระยะไกลของ TSM

ระบุตัวแปรสภาพแวดล้อม TSM_REMOTE_UID และ TSM_REMOTE_USERNAME เมื่อคุณสร้าง Tableau Server ในอิมเมจคอนเทนเนอร์โดยใช้เครื่องมือการตั้งค่า การสร้างบัญชีที่เปิดใช้งาน TSM ในอิมเมจจะต้องมีสิทธิ์การเข้าถึงในอิมเมจที่ไม่พร้อมใช้งานที่รันไทม์ และด้วยเหตุนี้จึงสามารถทำได้เมื่อ Tableau Server สร้างอิมเมจ Docker ในเครื่องมือการตั้งค่าคอนเทนเนอร์ (build-image)

ตัวอย่างของ Tableau Server ในไฟล์ environment ของเครื่องมือการตั้งค่าคอนเทนเนอร์

TSM_REMOTE_UID=1010
TSM_REMOTE_USERNAME=myuser

ตั้งรหัสผ่านสำหรับผู้ใช้ระยะไกลของ TSM

อิมเมจ Tableau Server ในคอนเทนเนอร์ต้องใช้รหัสผ่านสำหรับบัญชีเมื่อเรียกใช้อิมเมจ คุณสามารถตั้งรหัสผ่านให้กับบัญชีได้สองวิธี

ไฟล์ลับ (แนะนำ)

สร้างไฟล์ที่ชื่อ remote-user-secret เขียนรหัสผ่านลงในไฟล์และเชื่อมต่อเข้ากับคอนเทนเนอร์ที่รันไทม์ TSM_REMOTE_PASSWORD_FILE จะกำหนดตำแหน่งที่ตั้งที่คาดเอาไว้ (ตำแหน่งตามค่าเริ่มต้นคือ /docker/config/remote-user-secret) ของไฟล์ลับในคอนเทนเนอร์

ตัวอย่างไฟล์ remote-user-secret

mypassword

ตัวอย่างคำสั่งการเรียกใช้ Docker:

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>

ตัวแปรสภาพแวดล้อม

คุณสามารถตั้งเพียงแค่ตัวแปรสภาพแวดล้อม TSM_REMOTE_PASSWORD เมื่อเริ่มอิมเมจ Docker ได้

ตัวอย่างคำสั่งการเรียกใช้ Docker:

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>

หมายเหตุเพื่อความปลอดภัย

• ต้องเปิดพอร์ต 8850 เพื่อรับการรับส่งข้อมูลคำขอ TSM
• หากไม่ได้ตั้งรหัสผ่านในอิมเมจที่รันไทม์อย่างเหมาะสม คอนเทนเนอร์จะปิดตัวทันที
• TSM จะใช้ระบบบัญชีผู้ใช้ Linux ของอิมเมจ ในกรณีนี้ บัญชีจะถูกจำกัดภายในอิมเมจ ซึ่งหมายความว่าบัญชีจะมีเชลล์ถูกจำกัดและจะสามารถใช้ได้แค่สองคำสั่ง ได้แก่ /bin/true และ passwd

วิธีการหมุนเวียนรหัสผ่านของผู้ใช้ระยะไกล TSM

หากคุณต้องการหมุนเวียนรหัสผ่านของบัญชีผู้ใช้ระยะไกล TSM คุณสามารถทำได้โดยใช้ตัวเลือกต่อไปนี้

เริ่มต้น Tableau Server ในคอนเทนเนอร์ใหม่

ระบบจะตั้งรหัสผ่านของบัญชีทุกครั้งที่เริ่มคอนเทนเนอร์ หากคุณรักษาข้อมูลของ Tableau เอาไว้ภายนอกคอนเทนเนอร์ การเริ่มอิมเมจใหม่ทั้งหมดพร้อมรหัสผ่านใหม่จะเป็นการหมุนเวียนรหัสผ่านที่มีประสิทธิภาพ

1. ปิดและลบอิมเมจที่กำลังใช้งาน
2. ตั้งค่ารหัสผ่านใหม่ในตัวแปรสภาพแวดล้อม TSM_REMOTE_PASSWORD หรือ TSM_REMOTE_PASSWORD_FILE (ดูข้อมูลข้างต้น) ในการกำหนดค่าอิมเมจของคุณ
3. เริ่มอิมเมจอีกครั้ง

หมุนเวียนรหัสผ่านด้วยตนเองภายในคอนเทนเนอร์ที่กำลังทำงาน

หากคุณไม่ต้องการปิดอิมเมจ คุณสามารถหมุนเวียนรหัสผ่านด้วยตนเองได้เช่นกัน

1. เปิดเชลล์ในคอนเทนเนอร์ที่กำลังทำงาน
2. เข้าสู่ระบบด้วยบัญชีผู้ใช้ระยะไกล โดยใช้คำสั่ง su

3. เรียกใช้คำสั่ง passwd เพื่อเปลี่ยนรหัสผ่าน

   คำเตือน: การหมุนเวียนด้วยตนเองเหล่านี้จะคงมีผลตราบเท่าที่ยังคงมีเลเยอร์การเขียนของอินสแตนซ์คอนเทนเนอร์อยู่ หากคุณลบคอนเทนเนอร์ การเปลี่ยนแปลงด้วยตนเองจะไม่มีผลเมื่อเริ่มต้นคอนเทนเนอร์ใหม่

ตัวเลือกการกำหนดค่าเบื้องต้น

การกำหนดค่า Tableau Server ในคอนเทนเทนอร์คือขั้นตอนสำคัญเพื่อกำหนดพฤติกรรมที่คุณต้องการของ Tableau Server Tableau Server ในคอนเทนเนอร์คือการติดตั้งแบบ Tableau Server แบบล้างค่าเดิมจนหมดจด ดังนั้นคุณจึงต้องระบุข้อมูลเดิมให้กับคอนเทนเนอร์เหมือนกับที่คุณระบุข้อมูลให้ Tableau Server ภายนอกคอนเทนเนอร์

ตัวแปรสภาพแวดล้อมรันไทม์

ตัวแปรสภาพแวดล้อมรันไทม์ด้านล่างจะบอกอิมเมจ Tableau Server ในคอนเทนเนอร์ให้ทราบว่าควรปรับใช้ Tableau Server อย่างไร เราจะอธิบายชุดย่อยของตัวแปรเหล่านี้ให้ละเอียดยิ่งขึ้น

ค่าทั้งหมดเหล่านี้ได้รับการออกแบบให้ถูกแทนที่ เพื่อความยืดหยุ่นมากขึ้นสำหรับการกำหนดค่า

ตัวแปรสภาพแวดล้อม Randomly

นี่คือคุณสมบัติสภาพแวดล้อมที่อธิบายคุณสมบัติพื้นฐานบางอย่างของอิมเมจ Tableau Server ในคอนเทนเนอร์ เราไม่แนะนำให้แทนที่ค่าเหล่านี้

ตัวแปรสภาพแวดล้อมเวลาที่สร้าง

การแทนที่การกำหนดค่าของ Tableau Server

Docker จะสามารถเขียนทับตัวแปรสภาพแวดล้อมเหล่านี้กับจุดที่ไฟล์ใดๆ ในคอนเทนเนอร์ได้ ดังนั้นคุณสามารถระบุจุดเชื่อมต่ออื่นได้ ในกรณีที่คุณต้องการ

Tableau Server ต้องใช้ไฟล์การกำหนดค่าเพื่อเริ่มต้นและทำงาน:

CONFIG_FILE=/docker/config/config.json

CONFIG_FILE จะอ้างอิงถึงไฟล์การกำหนดค่า TSM รูปแบบและการใช้งานจะเหมือนกับไฟล์การกำหนดค่าที่อธิบายในตัวอย่างไฟล์การกำหนดค่า

คำสั่งก่อนการเริ่มต้นและหลังการเริ่มต้น

Tableau Server จะเรียกใช้สคริปต์การติดตั้งอัตโนมัติที่ออกแบบมาเพื่อเปลี่ยนเซิร์ฟเวอร์จากสถานะก่อนการเริ่มต้นเป็นการทำงานอย่างสมบูรณ์ แต่บางครั้งคุณอาจต้องเพิ่มโค้ดการทำงานอัตโนมัติของคุณในกระบวนการเริ่มต้น เราขอเสนอจุดแทรกโค้ดสองจุด รวมถึงสคริปต์ก่อนการเริ่มต้นและสคริปต์หลังการเริ่มต้น

สคริปต์ก่อนการเริ่มต้น

สคริปต์นี้จะทำงานทันทีหลังจากเริ่มต้นกระบวนการ TSM พื้นฐาน และก่อนที่จะดำเนินการตามขั้นตอนการตั้งค่า TSM อื่นๆ ซึ่งจะมีประโยชน์สำหรับการเรียกใช้คำสั่งการกำหนดค่า TSM ก่อนที่ Tableau Server จะทำงาน สำหรับการเปลี่ยนแปลงการกำหนดค่าในจุดนี้ คุณไม่จำเป็นต้องใช้การเปลี่ยนแปลง เนื่องจากตามปกติแล้วระบบอัตโนมัติของ Tableau Server จะดำเนินการหลังจากที่สคริปต์ของคุณดำเนินการเสร็จสิ้น

สคริปต์หลังการเริ่มต้น

สคริปต์นี้จะทำงานหลังจากการเริ่มต้น Tableau Server อื่นๆ ทั้งหมดและหลังจากที่ระบบการเริ่มต้นอัตโนมัติเสร็จสิ้น Tableau Server จะทำงานอย่างเต็มที่เมื่อสคริปต์นี้ทำงาน ต้องใช้การเปลี่ยนแปลงการกำหนดค่าที่จุดนี้

คำแนะนำ

หากต้องการเพิ่มสคริปต์ที่กำหนดเองลงในจุดแทรกโค้ดในอิมเมจของคุณ ให้ทำตามขั้นตอนต่อไปนี้

1. เขียนสคริปต์ที่กำหนดเองของคุณ
2. คัดลอกสคริปต์ที่กำหนดเองลงในไดเรกทอรี customer-files ของเครื่องมือสร้างอิมเมจ Tableau Server ในคอนเทนเนอร์
3. เปลี่ยนชื่อสคริปต์เป็น pre_init_command หรือ post_init_command โดยขึ้นอยู่กับว่าคุณต้องการให้เรียกใช้สคริปต์เมื่อใด (คุณสามารถใช้จุดแทรกโค้ดทั้งสองจุดโดยไม่ข้องเกี่ยวกันได้)
4. ตรวจดูสิทธิ์ของสคริปต์ว่าบุคคลอื่นสามารถใช้งานได้หรือไม่ (chmod +rx <command-file>) หรือสิทธิ์ความเป็นเจ้าของตรงกับผู้ใช้ที่ไม่ได้รับสิทธิ์ในคอนเทนเนอร์หรือไม่

การกำหนดค่าผู้ใช้

Tableau Server จะใช้ผู้ใช้ที่ไม่ได้รับสิทธิ์เพื่อเรียกใช้กระบวนการของเซิร์ฟเวอร์ ระบบจะสร้างผู้ใช้รายนี้ขึ้นในคอนเทนเนอร์เมื่อกำลังเริ่มต้น Tableau Server ในคอนเทนเนอร์ ตามค่าเริ่มต้น ผู้ใช้รายนี้จะชื่อ tableau โดยมี UID เป็น 999 หากคุณจะปรับใช้ Tableau Server ในคอนเทนเนอร์ที่ใช้การเชื่อมต่อกับข้อมูลที่จัดเก็บภายนอกบนเครื่องโฮสต์ คุณอาจต้องเปลี่ยน UID ให้ตรงกับ UID บนเครื่องโฮสต์ การใช้เนมสเปซของผู้ใช้ Docker ก็เป็นอีกวิธีที่ให้ผลลัพธ์แบบเดียวกัน

ยูทิลิตี้และเครื่องมือสำหรับ Tableau Server ในคอนเทนเนอร์

ฟังก์ชันทั้งหมดของยูทิลิตี้และเครื่องมือสำหรับ Tableau Server ในคอนเทนเนอร์จะอยู่ภายในไดเรกทอรีนี้:

/docker/

การจัดการสิทธิ์ของไฟล์

เมื่อส่งผ่านไฟล์การกำหนดค่าไปยังคอนเทนเนอร์ คุณจะต้องตรวจสอบว่าผู้ใช้ที่เรียกใช้กระบวนการ Tableau Server ภายในคอนเทนเนอร์มีสิทธิ์เข้าถึงไฟล์นั้น หากต้องการหลีกเลี่ยงการอนุญาตให้ผู้ใช้ทุกคนเข้าถึงไฟล์ที่เชื่อมต่อกับคอนเทนเนอร์ คุณสามารถเปลี่ยน UID และ/หรือ GID ของผู้ใช้ที่เรียกใช้ Tableau Server ภายในคอนเทนเนอร์ให้ตรงกับผู้ใช้/เจ้าของกลุ่มบนโฮสต์ ผู้ใช้คอนเทนเนอร์จะมี UID ที่กำหนดโดยตัวแปรสภาพแวดล้อม UNPRIVILEGED_TABLEAU_UID (ค่าเริ่มต้นคือ 999) และ GID ที่กำหนดโดย UNPRIVILEGED_TABLEAU_GID (ค่าเริ่มต้นคือ 998) ค่าเหล่านี้สามารถเปลี่ยนแปลงได้โดยการแทนที่ตัวแปรสภาพแวดล้อม หรือคุณสามารถใช้เนมสเปซผู้ใช้ Docker เพื่อเชื่อมโยง UID/GID ในคอนเทนเนอร์กับ UID/GID อื่นบนโฮสต์

การจัดการรหัสผ่าน

ฟีเจอร์และตัวเลือกบางอย่างจำเป็นต้องมีข้อมูลประจำตัวของผู้ใช้ตามการกำหนดค่าที่ตั้งค่าเอาไว้ในคอนเทนเนอร์ ข้อมูลเข้าสู่ระบบของผู้ดูแลระบบเริ่มต้นของ Tableau คือตัวอย่างของข้อมูลการเข้าสู่ระบบที่ทำให้ใช้งานฟีเจอร์เพิ่มเติมได้ ในกรณีเหล่านี้ เราจะมีสองวิธีในการตั้งรหัสผ่านเสมอ ขั้นแรก คุณสามารถระบุไฟล์ที่มีรหัสผ่านและระบุเส้นทางของไฟล์ไปที่ตัวแปรสภาพแวดล้อมได้ หรือคุณสามารถกำหนดให้ค่าตัวแปรสภาพแวดล้อมจัดเก็บรหัสผ่านโดยตรง

ตัวเลือกที่แนะนำและมีความปลอดภัยมากกว่าคือการระบุรหัสผ่านเป็นเส้นทางของไฟล์ไปยังคอนเทนเนอร์ การระบุข้อมูลลับในไฟล์เป็นรูปแบบที่ได้รับการสนับสนุนอย่างดีใน Docker, Docker Swarm, Kubernetes และระบบจัดการคอนเทนเนอร์อื่นๆ การจัดเก็บรหัสโดยตรงในตัวแปรสภาพแวดล้อมคือรูปแบบทั่วไปที่เรารองรับ แต่ก็เป็นวิธีที่ทำให้รหัสผ่านมีความปลอดภัยต่ำ

ตัวอย่าง

ลองมาดูตัวอย่างที่ข้อมูลเข้าสู่ระบบ TABLEAU_USERNAME คุณสามารถระบุรหัสผ่านให้ผู้ใช้เป็น TABLEAU_PASSWORD หรือ TABLEAU_PASSWORD_FILE ก็ได้ เมื่อเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์คุณสามารถกำหนดตัวแปรสภาพแวดล้อมที่จะระบุรหัสผ่านได้

ตัวแปรสภาพแวดล้อมของไฟล์รหัสผ่านต้องการเส้นทางไฟล์ภายในคอนเทนเนอร์ไปยังไฟล์ข้อมูลลับที่ถูกต้อง ไฟล์ข้อมูลลับควรมีข้อมูลลับบรรทัดเดียว

ตัวอย่างการใช้ไฟล์ข้อมูลลับ

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>

ตัวอย่างเนื้อหาของไฟล์ข้อมูลลับ

mypassword23879172

อีกทางหนึ่งสามารถจัดเก็บรหัสผ่านโดยตรงเป็นข้อความธรรมดาในตัวแปรสภาพแวดล้อมรหัสผ่าน วิธีนี้ถือว่ามีความปลอดภัยน้อยกว่า แต่มีความสะดวกมากกว่าและเป็นรูปแบบที่ใช้กันโดยทั่วไปกับคอนเทนเนอร์

ตัวอย่าง

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

การกำหนดค่า Tableau Server หลังจากที่ทำงาน

เมื่อ Tableau Server เริ่มต้นและทำงานแล้ว วิธีการที่ดีที่สุดในการโต้ตอบกับเซิร์ฟเวอร์คือการใช้เครื่องมือ TSM CLI นี่คือเครื่องมือคลาสสิกของ Tableau Server ในการทำงานของผู้ดูแลระบบ ในอนาคต เราจะพัฒนาการโต้ตอบของ Tableau Server ให้สอดรับกับการเปลี่ยนแปลงในการกำหนดค่าแบบคงที่ที่ระบุในตัวแปรสภาพแวดล้อม CONFIG_FILE ในระหว่างการทำงาน แต่ในขณะนี้ หลังจากที่ Tableau Server เริ่มต้นแล้ว คุณจะต้องโต้ตอบกับเซิร์ฟเวอร์โดยใช้เครื่องมือคลาสสิก

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับบรรทัดคำสั่งของ TSM โปรดดู ข้อมูลอ้างอิงบรรทัดคำสั่ง tsm

สถานะ

มีการตรวจสอบสถานะพื้นฐานสำหรับ Tableau Server อยู่สองรูปแบบในอิมเมจ ซึ่งสามารถใช้เพื่อตรวจสอบสถานะการทำงานและความพร้อมของเซิร์ฟเวอร์

การตรวจสอบสถานะการทำงาน

การตรวจสอบสถานะการทำงานจะบ่งชี้ว่าบริการ TSM กำลังทำงานอยู่หรือไม่ ซึ่งจะบ่งชี้ว่าบริการที่จัดเตรียมเอาไว้ของ Tableau Server กำลังทำงานตามปกติอยู่หรือไม่ สามารถเรียกการตรวจสอบได้ดังนี้:

/docker/alive-check

อีกทางเลือกหนึ่งคือการเปิดพอร์ต 8850 ซึ่งบริการ Tableau Controller ใช้เพื่อให้บริการฟังก์ชันสำหรับการดูแลระบบผ่านเว็บเบราว์เซอร์ ซึ่งสามารถตรวจสอบความสมบูรณ์ของบริการเป็นระยะได้โดยการตรวจสอบความสมบูรณ์ของบริการผ่านการตรวจสอบสภาพการทำงานของ tcp

การตรวจสอบความพร้อม

การตรวจสอบความพร้อมจะบ่งชี้ว่า Tableau Server กำลังทำงานและบริการทางธุรกิจพร้อมที่จะรับข้อมูลหรือไม่ ซึ่งสามารถตรวจสอบได้โดยใช้สคริปต์ต่อไปนี้:

/docker/server-ready-check

อีกทางเลือกหนึ่งคือใช้การตรวจสอบสภาพการทำงานของ tcp กับพอร์ต 8080 (หรือพอร์ต Tableau Server ใดก็ได้ที่ผูกไว้เพื่อรับข้อมูล) บางครั้งการตรวจสอบสภาพการทำงานของ tcp ด้วยวิธีนี้มีความเชื่อถือมากกว่าการตรวจสอบความพร้อมของเซิร์ฟเวอร์ เนื่องจากการตรวจสอบความพร้อมของเซิร์ฟเวอร์จะขึ้นอยู่กับสถานะบริการที่รายงานไปยัง TSM ซึ่งบางครั้งอาจล่าช้าเพราะการอัปเดตสถานะบริการ

การรักษาข้อมูล

บ่อยครั้ง เราต้องการความสามารถในการปิดคอนเทนเนอร์แล้วเปิดขึ้นมาใหม่โดยไม่สูญเสียข้อมูลสำคัญใดๆ อิมเมจ Tableau Server ในคอนเทนเนอร์รองรับกระบวนการนี้โดยคุณสามารถเชื่อมต่อไดเรกทอรีบางส่วนนอกคอนเทนเนอร์เพื่อให้คุณสามารถทำลายหรือลบอินสแตนซ์ของคอนเทนเนอร์ได้อย่างสมบูรณ์โดยที่ยังคงรักษาข้อมูลของคุณเอาไว้ เราสามารถใช้ข้อมูลนี้เพื่อเริ่มต้นอินสแตนซ์ของคอนเทนเนอร์อื่น และทำงานต่อในตำแหน่งที่ค้างเอาไว้ในคอนเทนเนอร์ก่อนหน้า

ส่วนต่อไปนี้ครอบคลุมถึงสถานะที่มีการจัดการประเภทต่างๆ

ข้อมูลของ Tableau Server

ข้อมูลของเซิร์ฟเวอร์ทั้งหมดจะจัดเก็บเอาไว้ในไดเรกทอรีข้อมูล ไดเรกทอรีข้อมูลเป็นพื้นที่เก็บข้อมูลที่เกี่ยวข้องกับผู้ใช้และข้อมูลเมตารันไทม์ของบริการทั้งหมด การเปลี่ยนข้อมูลนี้ให้เป็นข้อมูลภายนอก หมายความว่าคุณสามารถรักษาข้อมูลผู้ใช้ของคุณเอาไว้ได้แม้ว่า Tableau Server ในคอนเทนเนอร์จะถูกลบออกอย่างสมบูรณ์

ข้อมูลนี้สามารถถ่ายโอนได้และสามารถใช้ได้กับระบบจัดเก็บข้อมูลแบบบล็อกที่จัดการบนคลาวด์ เช่น วอลุ่มของ AWS EBS

เมื่อมีการใช้ Tableau Server ในคอนเทนเนอร์ร่วมกับที่เก็บไฟล์ภายนอก ไดเรกทอรีข้อมูลจะต้องอยู่ใน EBS ห้ามใช้ระบบไฟล์เครือข่าย (เช่น NFS) กับไดเรกทอรีข้อมูล ไดเรกทอรีที่เก็บไฟล์ภายนอกสามารถอยู่บนวอลุ่ม NFS ได้

ชื่อโฮสต์แบบคงที่

Tableau Server จัดการเปลี่ยนแปลงชื่อโฮสต์แบบไดนามิกได้ไม่ดีนัก ดังนั้นการระบุชื่อโฮสต์ภายในของคอนเทนเนอร์จึงจำเป็น เพื่อให้สอดคล้องระหว่างการเรียกใช้คอนเทนเนอร์ ชื่อโฮสต์ภายในคอนเทนเนอร์สามารถกำหนดได้เองและสามารถตั้งเป็นค่าใดก็ได้ การใช้ตัวเลือก --hostname จะอนุญาตให้ระบุชื่อโฮสต์ภายในของคอนเทนเนอร์ได้ ตรวจสอบว่าคอนเทนเนอร์ที่ตามมาซึ่งใช้ข้อมูลถาวรชุดเดียวกัน ทำงานโดยใช้ค่าชื่อโฮสต์เดียวกัน

โปรดอย่าสับสนกับการติดตั้งเซิร์ฟเวอร์แบบหลายโหนด ในกรณีนี้ ควรกำหนดชื่อโฮสต์ที่แตกต่างกันให้กับโหนดเพิ่มเติมแต่ละโหนด ข้อสำคัญคือ เมื่อมีการรีสตาร์ทคอนเทนเนอร์เดียว คอนเทนเนอร์แทนที่ที่จะใช้ข้อมูลถาวรชุดเดียวกันสำหรับอินสแตนซ์นั้นจะต้องมีชื่อโฮสต์ตรงกัน

ตัวอย่างที่สมบูรณ์

นี่คือตัวอย่างที่ไดเรกทอรีข้อมูลที่เชื่อมต่ออยู่ภายนอกคอนเทนเนอร์

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>

สำรองข้อมูลและคืนค่า

Tableau Server ในคอนเทนเนอร์รองรับ Tableau Server ที่สร้างการสำรองข้อมูลและคืนค่าจากไฟล์สำรองข้อมูล (.tsbak) ขั้นตอนแรกคือการเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์ เชื่อมต่อไฟล์สำรองข้อมูล (.tsbak) เข้ากับอิมเมจ แล้วตั้งตัวแปรสภาพแวดล้อม BACKUP_FILE กับเส้นทางไฟล์ไปยังไฟล์สำรองข้อมูล นอกจากนี้ คุณต้องจัดเตรียมไฟล์การกำหนดค่าในตัวแปรสภาพแวดล้อม CONFIG_FILE คอนเทนเนอร์ Tableau Server จะดำเนินกระบวนการคืนค่าโดยอัตโนมัติ แม้จะเป็นการปรับใช้แบบหลายโหนด หากระบบอัตโนมัตินี้ไม่สามารถกู้คืนระบบได้อย่างสมบูรณ์ไม่ว่าจะในขั้นตอนใด คุณสามารถย้อนกลับบนเครื่องมือและกระบวนการคลาสสิกของ Tableau Server ได้ เช่น ใช้คำสั่ง TSM เพื่อโต้ตอบกับ Tableau Server ในลักษณะเดียวกับที่คุณทำกับการปรับใช้ที่ไม่ใช่คอนเทนเนอร์

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการสำรองข้อมูลและคืนค่าอินสแตนซ์มาตรฐานของ Tableau Server โปรดดู ดำเนินการสำรองข้อมูลและกู้คืน Tableau Server อย่างเต็มรูปแบบ

สำรองข้อมูลในคอนเทนเนอร์ Tableau Server

1. เปิดเชลล์ภายใน Tableau Server ในคอนเทนเนอร์เวอร์ชัน A สร้างข้อมูลสำรองให้ที่เก็บ รวมถึงโทโพโลยีและไฟล์สำรองข้อมูลการกำหนดค่า

   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. คัดลอกไฟล์ที่สร้างขึ้นในขั้นตอนก่อนหน้าไปที่เครื่องโฮสต์ เปลี่ยนสิทธิ์ของทั้งสองไฟล์ให้มีสิทธิ์อ่านทั้งหมด

   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. จัดเก็บไฟล์การสำรองข้อมูลในพื้นที่ที่ปลอดภัย ดำเนินการตามขั้นตอนคืนค่าด้านล่างเมื่อต้องการ

คืนค่าภายในคอนเทนเนอร์ของ Tableau Server

คุณสามารถคืนค่าข้อมูลสำรองจากเวอร์ชัน Tableau Server ที่รองรับ (ทั้งแบบคอนเทนเนอร์และไม่ใช่คอนเทนเนอร์) ภายในคอนเทนเนอร์ Tableau Server

ข้อกำหนดเบื้องต้น

• ไฟล์สำรองข้อมูล Tableau Server
  
• ไฟล์การกำหนดค่า json ที่มีทั้งข้อมูลการกำหนดค่าและข้อมูลโทโพโลยี
• ไฟล์ JSON การกำหนดค่าที่ประกอบด้วยข้อมูลที่เก็บข้อมูลประจำตัว
• หมายเหตุ: คุณอาจต้องเปลี่ยนไฟล์สำรองข้อมูลเพื่อให้มีสิทธิ์การอ่านทั้งหมด โดยปกติแล้ว ไฟล์สำรองข้อมูลมักจะล็อกกับผู้ใช้ที่สร้างไฟล์ และน่าจะแตกต่างจากผู้ใช้ Tableau ที่ทำงานอยู่ในคอนเทนเนอร์

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>

หมายเหตุ:

• หากคุณกำลังคืนค่าให้ระบบแบบหลายโหนด คุณต้องเริ่มโหนดอื่นด้วย เพื่อให้ระบบคืนค่าอัตโนมัติทำงาน ดูข้อมูลเพิ่มเติมที่ส่วนTableau Server แบบหลายโหนดในคอนเทนเนอร์ของเอกสารนี้ เฉพาะโหนดแรกเท่านั้นที่ต้องการไฟล์ข้อมูลสำรอง ไฟล์การกำหนดค่าสำรอง และสิทธิ์อนุญาต
• ต้องระบุเฉพาะไฟล์สำรองข้อมูลเท่านั้นในการเรียกใช้คอนเทนเนอร์ครั้งแรก เมื่อเริ่มต้นเซิร์ฟเวอร์แล้ว คุณไม่จำเป็นต้องเชื่อมต่อในไฟล์สำรองข้อมูลอีกต่อไป

การย้ายจาก Tableau Server ไปที่ Tableau Server ในคอนเทนเนอร์

หากต้องการย้ายจากการติดตั้ง Tableau Server แบบมาตรฐานไปที่ Tableau Server ในคอนเทนเนอร์ คุณจะต้องใช้เทคนิคการสำรองข้อมูลและการคืนค่า คุณสามารถคืนค่าข้อมูลสำรองจากเวอร์ชัน Tableau Server ที่รองรับ (ทั้งแบบคอนเทนเนอร์และไม่ใช่คอนเทนเนอร์) ภายในคอนเทนเนอร์ Tableau Server ดูข้อมูลเพิ่มเติมที่ส่วนคืนค่าภายในคอนเทนเนอร์ของ Tableau Server ทางด้านบน

การอัปเกรดเวอร์ชันของ Tableau Server

การอัปเกรด Tableau Server มีสองวิธีดังนี้ วิธีการใช้อิมเมจอัปเกรดที่แสดงในส่วนนี้เป็นโซลูชันที่แนะนำ อย่างไรก็ตาม การอัปเกรด Tableau Server โดยใช้การสำรองข้อมูล/คืนค่า ก็เป็นวิธีสำรองที่สามารถใช้ได้เช่นกัน

การอัปเกรดด้วยอิมเมจอัปเกรด

อิมเมจอัปเกรดคืออิมเมจของ Docker ที่สามารถสร้างขึ้นโดยใช้สคริปต์ build-upgrade-image จากเครื่องมือการตั้งค่า Tableau Server ในคอนเทนเนอร์ จุดประสงค์ของอิมเมจนี้คือการอัปเกรด Tableau Server ในคอนเทนเนอร์ที่กำลังทำงานอยู่เท่านั้น

โปรดทำตามขั้นตอนด้านล่างนี้เพื่ออัปเกรด

1. สร้างอิมเมจอัปเกรดโดยใช้สคริปต์ build-upgrade-image จำเป็นต้องมี Tableau Server RPM ของเวอร์ชันใหม่เพื่อสร้างคอนเทนเนอร์นี้
2. ปิดคอนเทนเนอร์ที่กำลังใช้งาน Tableau Server
3. เริ่มอิมเมจอัปเกรด ติดตั้งไดเรกทอรีข้อมูลเดียวกันจากคอนเทนเนอร์ที่ปิดในขั้นตอนก่อนหน้า
4. กระบวนการอัปเกรดจะใช้เวลาสักครู่ เมื่อ Tableau Server ได้รับการอัปเกรดแล้ว ให้ตรวจดูบันทึกการอัปเดตกระบวนการอัปเกรดของ Docker คอนเทนเนอร์จะปิดลงหลังเสร็จสิ้นกระบวนการอัปเกรด
5. เริ่ม Tableau Server ในคอนเทนเนอร์เวอร์ชันใหม่ เชื่อมต่อไดเรกทอรีเดียวกันจากขั้นตอนก่อนหน้านี้

ตัวอย่าง:

สมมติว่าเรามี Tableau Server ในคอนเทนเนอร์ที่ใช้งาน Tableau Server นี้คือเป็นข้อสันนิษฐานบางประการในตัวอย่างนี้

• ฉันมีข้อมูลสำคัญ และฉันไม่ต้องการสูญเสียข้อมูลใดๆ ระหว่างกระบวนการอัปเกรด จะต้องเก็บรักษาไดเรกทอรีข้อมูลเอาไว้ภายนอกคอนเทนเนอร์
• คอนเทนเนอร์ชื่อ my-server อิมเมจ Docker ชื่อ tableau-server:versionA.
• เวอร์ชันของเซิร์ฟเวอร์ที่ my-server กำลังใช้คือเวอร์ชัน A.
• เวอร์ชันของเซิร์ฟเวอร์ที่ฉันต้องการอัปเกรดคือเวอร์ชัน B

1. เตรียม Tableau Server RPM สำหรับเวอร์ชัน B แล้วสร้างอิมเมจอัปเกรด

   # 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. หยุดคอนเทนเนอร์ my-server

   docker stop my-server -t 120

3. เริ่มอิมเมจที่สร้างขึ้นใหม่ tableau-server-upgrade:versionAB เชื่อมต่อไดเรกทอรีข้อมูลเดียวกันจากคอนเทนเนอร์ที่หยุดไปก่อนหน้านี้ คอนเทนเนอร์จะเริ่มกระบวนการอัปเกรดเป็นเวอร์ชัน B

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

4. คอนเทนเนอร์จะหยุดเมื่อการอัปเกรดสมบูรณ์ ตรวจดูบันทึก Docker เพื่อตรวจสอบบันทึกกระบวนการอัปเกรดให้แน่ใจว่ากระบวนการอัปเกรดสำเร็จแล้ว คุณสามารถตรวจสอบโค้ดออกจากการทำงานของคอนเทนเนอร์ Docker เพื่อให้แน่ใจว่ากระบวนการอัปเกรดเสร็จสมบูรณ์แล้วได้เช่นกัน

   # 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. หยุดคอนเทนเนอร์ my-upgrade-server เริ่ม Tableau Server เวอร์ชัน B ใหม่ในอิมเมจคอนเทนเนอร์ แล้วเชื่อมต่อไดเรกทอรีข้อมูลจากคอนเทนเนอร์ my-upgrade-server ที่หยุดไป

   # 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

การอัปเกรดผ่านวิธีการสำรองข้อมูล-คืนค่า

ทำตามขั้นตอนในส่วนสำรองข้อมูลและคืนค่าของเอกสารนี้ โดยเปลี่ยนขั้นตอนการคืนค่าข้อมูลสำรองเป็น Tableau Server เวอร์ชันใหม่ เพียงขั้นตอนเดียวในการสำรองข้อมูลและคืนค่า

Tableau Server แบบหลายโหนดในคอนเทนเนอร์

Tableau Server แบบหลายโหนดในคอนเทนเนอร์คือการปรับใช้ Tableau Server ครั้งเดียวโดยกระจายไปในหลายโหนด คำว่าหลายโหนดในบริบทนี้เหมือนกับคำว่าหลายโหนดของ Tableau Server ซึ่งสามารถเรียกใช้กระบวนการบางอย่างบนโหนดอื่นๆ เพื่อเพิ่มความจุ กำลังประมวลผล ฯลฯ โดยจะแตกต่างจากการเริ่ม Tableau Server ในคอนเทนเนอร์หลายคอนเทนเนอร์แยกกัน และแต่ละคอนเทนเนอร์เป็นเซิร์ฟเวอร์อิสระที่มีข้อมูลที่แตกต่างกันเป็นของตนเอง

Tableau Server แบบหลายโหนดในคอนเทนเนอร์จะทำงานเหมือนกับการติดตั้ง Tableau Server แบบหลายโหนดที่ไม่ใช้คอนเทนเนอร์ และจะใช้กลไกเบื้องหลังเหมือนกัน หากต้องการดูภาพรวมการตั้งค่าการติดตั้ง Tableau Server แบบหลายโหนดที่ไม่ใช้คอนเทนเนอร์ โปรดดู การติดตั้ง Tableau Server แบบกระจายและมีความพร้อมใช้งานสูง

ตัวอย่างมีดังนี้

การใช้งานพื้นฐานของโหนดหลายโหนด

โหนดเริ่มต้น

ตัวเลือกที่ 1: ใช้ตัวเลือกนี้หากการกำหนดค่าเซิร์ฟเวอร์ (CONFIG_FILE) ระบุโทโพโลยีแบบหลายโหนด:

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>

ตัวเลือกที่ 2: ใช้ตัวเลือกนี้หากคุณต้องการปรับใช้หลายโหนดแม้การกำหนดค่าเซิร์ฟเวอร์จะไม่ได้ระบุโทโพโลยีแบบหลายโหนดก็ตาม:

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>

โหนดเพิ่มเติม

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>

การเปิดสิทธิ์อนุญาตและพอร์ต TSM

หากต้องการให้โหนดของผู้ปฏิบัติงานสื่อสารกับอินสแตนซ์หลัก เราจำเป็นต้องเปิดพอร์ตเพิ่มเติม คุณจะต้องอนุญาตการรับส่งข้อมูลจากโหนดอื่นบนอินสแตนซ์ Tableau Server ในคอนเทนเนอร์หลักของคุณในช่วงพอร์ตต่อไปนี้:

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

ระวังจำนวนพอร์ตที่คุณเปิด: เราขอแนะนำให้เปิดเพียง 200 พอร์ตในช่วง 8800-9000 แทนที่ช่วงพอร์ตตามค่าเริ่มต้นของ Tableau Server ที่ 8000-9000 เพราะการเปิด 1000 พอร์ตใน Docker อาจส่งผลเสียต่อประสิทธิภาพและเวลาการเริ่มอิมเมจ Docker คุณสามารถใช้ช่วงพอร์ตที่เล็กลงหรือใหญ่ขึ้นได้ ขึ้นอยู่กับความซับซ้อนของโทโพโลยี Tableau Server ของคุณ โดยทั่วไป เราไม่แนะนำให้เปิดพอร์ตน้อยกว่า 100 พอร์ต มิฉะนั้นคุณอาจมีความเสี่ยงที่บริการในคลัสเตอร์จะไม่สามารถสื่อสารกับบริการบางอย่างได้ หากคุณระบุช่วงพอร์ตของคุณเอง โปรดตรวจสอบว่าคุณเปิดพอร์ต 8850 (ซึ่งรวมอยู่ใน 8800-9000 อยู่แล้ว) สามารถระบุช่วงพอร์ตได้โดยการตั้งค่าตัวแปรสภาพแวดล้อม PORT_RANGE_MIN and PORT_RANGE_MAX

สำหรับโหนดเพิ่มเติม จะต้องเปิดช่วงพอร์ตบริการ (8800-9000) ด้วยเช่นกัน แต่ไม่ใช่ช่วงพอร์ตการให้สิทธิ์อนุญาต คุณจำเป็นต้องทราบว่าช่วงพอร์ตเหล่านี้อนุญาตให้มีการสื่อสารระหว่างกระบวนการของ Tableau Server เท่านั้น คุณไม่ควรเปิดพอร์ตให้กับผู้ใช้หรือเครื่องอื่นๆ นอกเหนือจากคอมพิวเตอร์ที่กำลังใช้ Tableau Server ในคอนเทนเนอร์สำหรับคลัสเตอร์แบบหลายโหนดเดียวกัน

กฎพอร์ตเหล่านี้จะสอดคล้องกับเอกสารไฟร์วอลล์ของ Tableau Server หากต้องการข้อมูลเพิ่มเติม โปรดดูหัวข้อ กำหนดค่าไฟร์วอลล์ในเครื่อง

การแก้ปัญหาชื่อโฮสต์

โหนดหลายโหนดของ Tableau Server ในคอนเทนเนอร์จำเป็นต้องเรียกใช้ด้วยชื่อโฮสต์เดียวกัน เพราะ Tableau Server ไม่ดำเนินการกับการเปลี่ยนชื่อโฮสต์แบบไดนามิก เมื่อเรียกใช้ Tableau Server แบบหลายโหนด โหนดเหล่านี้จะต้องสื่อสารต่อกัน โหนดของ Tableau Server จะพยายามติดต่อกันโดยใช้ชื่อโฮสต์ที่การกำหนดค่า Tableau Server ในคอนเทนเนอร์ของหลายโหนดกำหนดให้ใช้ ตัวอย่างเช่น หากคุณเรียกใช้โหนดเริ่มต้นที่มีชื่อโฮสต์ "initial" โหนดเพิ่มเติมจะพยายามส่งข้อมูลไปยังโฮสต์ที่ชื่อ "initial" คุณสามารถกำหนดค่าอิมเมจเพื่อแก้ไขชื่อโฮสต์เป็นอิมเมจอื่นได้หลายวิธี ไฟล์ /etc/hosts ในแต่ละคอนเทนเนอร์เพื่อแมปชื่อโฮสต์คอนเทนเนอร์ที่กำหนดเอง (เช่น "initial") กับที่อยู่ IP ที่เรียกใช้คอนเทนเนอร์อื่นอยู๋จริง

การบูตสแตรปโหนดเพิ่มเติม

คอนเทนเนอร์ Tableau Server เริ่มต้นที่ทำงานเป็นส่วนหนึ่งของคลัสเตอร์จะสร้างไฟล์บูตสแตรปที่โหนดเพิ่มเติมที่ตามมาจะต้องใช้เพื่อเข้าร่วมคลัสเตอร์ หลังจากลงทะเบียนโหนดเพิ่มเติมในโทโพโลยีของคลัสเตอร์แล้ว คุณสามารถเริ่มกำหนดกระบวนการ Tableau Server เพื่อเรียกใช้บนโหนดเหล่านี้ได้ กระบวนการนี้จะทำงานอัตโนมัติเต็มรูปแบบ หากคุณได้จัดเตรียมไฟล์การกำหนดค่าของ Tableau Server (โดยทั่วไปแล้วโดยการติดตั้งไฟล์การกำหนดค่าไปที่เส้นทางไฟล์ที่ระบุโดย CONFIG_FILE เส้นทางตามค่าเริ่มต้น: /docker/config/config.json) ที่ระบุโทโพโลยีแบบหลายโหนด โหนดเริ่มต้นจะรอโดยอัตโนมัติจนกว่าโหนดเพิ่มเติมจะลงทะเบียนแล้ว เมื่อลงทะเบียนแล้ว ระบบจะใช้โทโพโลยีแบบหลายโหนดกับทั้งคลัสเตอร์

เมื่อโหนดเริ่มต้นใน Tableau Server ในคอนเทนเนอร์เรียกใช้ Tableau Server อย่างเต็มที่แล้ว คุณสามารถสร้างไฟล์บูตสแตรปสำหรับโหนดเพิ่มเติมได้ ดังนี้

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

ระบบจะเรียกคำสั่งนี้ให้คุณโดยอัตโนมัติหากคุณตั้งค่า ALWAYS_WRITE_BOOTSTRAP_FILE เป็น 1

ข้อควรพิจารณาด้านความปลอดภัย

ไฟล์บูตสแตรปมีข้อมูลลับของเซิร์ฟเวอร์ที่อนุญาตให้สร้างเซสชัน TSM ด้วยโหนดเริ่มต้น ซึ่งหมายความว่าหากผู้ใช้ที่เป็นอันตรายได้รับไฟล์ พวกเขาสามารถส่งคำสั่ง TSM ไปยังเซิร์ฟเวอร์ได้ในช่วงระยะเวลาหนึ่ง และตัวไฟล์ยังมีข้อมูลที่จะเปิดใช้งานการถอดรหัสข้อมูลลับของการกำหนดค่าเซิร์ฟเวอร์ คุณจึงควรปฏิบัติต่อไฟล์นี้อย่างระมัดระวัง และควรจำกัดเฉพาะบริการและระบบที่เกี่ยวข้องโดยตรงกับการสร้างการปรับใช้แบบหลายโหนดเท่านั้นให้สามารถเข้าถึงได้

การหมดอายุของบูตสแตรป

ไฟล์บูตสแตรปมีเซสชันจำกัดเวลานาน 2 ชั่วโมง ในช่วงเวลานั้น โหนดเพิ่มเติมจะต้องระบุข้อมูลประจำตัวให้กับโหนดเริ่มต้นเพื่อเข้าร่วมเป็นโหนดเพิ่มเติม คุณสามารถใช้ไฟล์บูตสแตรปเมื่อเซสชันหมดอายุไปแล้วได้ แต่คุณจะต้องระบุข้อมูลประจำตัวให้กับโหนดเริ่มต้น

การย้ายไฟล์บูตสแตรป

ไฟล์บูตสแตรปจะต้องพร้อมใช้งานและนำไปใช้งานโดย Tableau Server ของโหนดผู้ปฏิบัติงานในคอนเทนเนอร์ ไฟล์บูตสแตรปจะต้องแชร์ให้กับ Tableau Server ของโหนดอื่นทั้งหมดในคอนเทนเนอร์ที่คุณต้องการใช้เป็นโหนดของผู้ปฏิบัติงานสำหรับการปรับใช้นี้ ซึ่งสามารถทำได้หลายวิธี

การโอนย้ายไฟล์ข้ามเครือข่ายที่ปลอดภัย

ระบบอัตโนมัติบางส่วนของคุณบนโหนดเริ่มต้น อาจเกี่ยวข้องกับการส่งไฟล์ไปยังโหนดเพิ่มเติมโดยตรง ควรทำขั้นตอนนี้โดยใช้ไคลเอ็นต์/เครื่องมือการถ่ายโอนไฟล์ที่ปลอดภัย ซึ่งอาจเป็นประโยชน์ในสถานการณ์ที่ต้องสร้างไฟล์บูตสแตรปหลายไฟล์ตลอดอายุของโหนดเริ่มต้น (อาจเพิ่มโหนดเพิ่มเติมในภายหลัง)

ใช้การเชื่อมต่อไฟล์เครือข่าย

การเชื่อมต่อไฟล์เครือข่ายที่แชร์โดยคอนเทนเนอร์ทั้งหมดในการปรับใช้ที่กำหนดเป็นอีกทางเลือกหนึ่ง

อื่นๆ

เป้าหมายสุดท้ายคือการถ่ายโอนไฟล์ที่สร้างโดยคอนเทนเนอร์อย่างปลอดภัย และโอนไปยังชุดคอนเทนเนอร์อื่นที่เฉพาะเจาะจง ดังนั้นวิธีการที่ช่วยให้ทำได้สำเร็จและปลอดภัยนับว่าเป็นวิธีที่เพียงพอ

การเริ่มโหนดเพิ่มเติม

หากต้องการเริ่มโหนดเพิ่มเติมของ Tableau Server ในคอนเทนเนอร์ ให้เริ่มคอนเทนเนอร์โดยกำหนดตัวแปรสภาพแวดล้อม BOOTSTRAP_INSTALL เป็น 1

การดำเนินการนี้จะบอกให้อินสแตนซ์ของ Tableau Server ในคอนเทนเนอร์เข้าสู่โหมดสลีปจนกว่าไฟล์บูตสแตรปจะอยู่บนเส้นทางที่ตัวแปรสภาพแวดล้อม BOOTSTRAP_FILE ระบุ (ซึ่งสามารถกำหนดค่าได้เช่นกัน) โปรดดู เส้นทางไฟล์ตามค่าเริ่มต้นจากตารางตัวแปรสภาพแวดล้อม เพื่อความชัดเจนยิ่งขึ้น หากคุณเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์ใน "โหมดโหนดเพิ่มเติม" คอนเทนเนอร์จะไม่เริ่ม supervisord หรือกระบวนการอื่นๆ นอกเหนือจากสคริปต์บาชที่ทำงานเป็น pid 1 ซึ่งจะตรวจสอบทุก 5 วินาทีเพื่อดูว่ามีไฟล์บูตสแตรปอยู่หรือไม่ เมื่อตรวจพบไฟล์แล้ว Tableau Server ในคอนเทนเนอร์จะดำเนินการเริ่มการทำงานเป็นโหนดเพิ่มเติม

การกำหนดค่าโหนดเพิ่มเติม

การกำหนดค่าโหนดเพิ่มเติมเพื่อเรียกใช้โทโพโลยีเฉพาะ จะทำงานเหมือนกับขั้นตอนในการปรับใช้ Tableau Server ปกติ นอกจากนี้ยังมาพร้อมกับข้อกำหนดเดียวกัน ซึ่งหมายความว่าการเพิ่มกระบวนการใหม่บนโหนดอาจต้องรีสตาร์ททั้งคลัสเตอร์ หากต้องการข้อมูลเพิ่มเติม โปรดดู กำหนดค่าโหนด

ข้อควรพิจารณาสำหรับฟีเจอร์ของ Tableau Server

ฟีเจอร์ Tableau Server บางอย่างทำงานแตกต่างกันในคอนเทนเนอร์ ส่วนนี้จะครอบคลุมฟีเจอร์ที่เฉพาะเจาะจงที่มีข้อควรพิจารณาพิเศษหรือแตกต่างในสภาพแวดล้อมคอนเทนเนอร์

Active Directory

ตั้งค่าตัวควบคุมโดเมน AD

หากคุณวางแผนที่จะใช้ Active Directory เป็นที่เก็บข้อมูลประจำตัวสำหรับหน้าเว็บ Tableau Server ก็มีข้อควรพิจารณาเพิ่มเติมที่ควรคำนึงถึง Tableau Server ที่ทำงานในสภาพแวดล้อม Linux จะระบุเชิงไดนามิกว่าต้องสื่อสารกับตัวควบคุมโดเมน AD ใดด้วยการตรวจสอบซับเน็ต IP สามารถมอบหมายที่อยู่ IP ที่กำหนดเองแก่คอนเทนเนอร์ และในกรณีนี้ Tableau Server จะไม่จำเป็นต้องใช้ที่อยู่ IP เพื่อค้นหาตัวควบคุมโดเมนที่เหมาะสม ด้วยเหตุนี้ จึงอาจมีความจำเป็นต้องกำหนดค่าตัวควบคุมโดเมน / ชื่อโฮสต์ที่เฉพาะเจาะจงเพื่อให้ Tableau Server สื่อสารด้วย ซึ่งสามารถทำตามขั้นตอนเหล่านี้:

1. กำหนดว่าคุณต้องการให้ Tableau Server ใช้ตัวควบคุมโดเมนใดและรับข้อมูลชื่อโฮสต์

2. ตั้งค่าการกำหนดค่าคีย์ wgserver.domain.ldap.hostname เป็นชื่อโฮสต์ที่ใช้ตัวเลือกการกำหนดค่าผู้ดูแลระบบ Tableau Server มาตรฐาน:

   • กำหนดค่าในไฟล์การกำหนดค่า json CONFIG_FILE

   • ใช้คำสั่งการกำหนดค่า TSM

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

ส่งออกใบรับรอง AD ไปยังคีย์สโตร์ Tableau Server

ตามค่าเริ่มต้นแล้ว Tableau Server ในคอนเทนเนอร์จะสื่อสารกับ AD ผ่าน StartTLS เมื่อใดก็ตามที่มีการผูกโยงค่าแบบง่าย ดังนั้นเมื่อคอนเทนเนอร์ทำงานด้วยการกำหนดค่านี้ เป็นสิ่งจำเป็นที่จะต้องนำเข้าใบรับรองเซิร์ฟเวอร์ AD ไปยังคีย์สโตร์ Tableau Server มิเช่นนั้นการเริ่มต้นทำงานของเซิร์ฟเวอร์จะไม่สำเร็จ ซึ่งสามารถทำตามขั้นตอนเหล่านี้:

1. สร้างสคริปต์ pre-init-command (ดูที่ส่วนสคริปต์ก่อนการเริ่มต้นทำงาน) เพิ่มบรรทัดต่อไปนี้เพื่อเพิ่มใบรับรอง AD ไปยังคีย์สโตร์ Tableau Server

   ${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. ติดตั้งใบรับรองเซิร์ฟเวอร์ AD ที่เส้นทางไฟล์ที่ระบุสำหรับพารามิเตอร์ -file ในสคริปต์ pre-init-command

หรือสามารถปิดใช้งานการตั้งค่าเริ่มต้นให้สื่อสารกับ AD ผ่าน StartTLS ตั้งค่า wgserver.domain.ldap.starttls.enabled เป็น false เพื่อปิดใช้งาน StartTLS แต่ไม่แนะนำให้ทำเช่นนี้

ตัวอย่างการกำหนดค่าการปรับใช้

Docker

การใช้งานพื้นฐานของ Tableau Server ในคอนเทนเนอร์

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

การใช้งานพื้นฐานของ Tableau Server ในคอนเทนเนอร์พร้อมผู้ใช้ที่เป็นผู้ดูแลระบบเริ่มต้นที่ทำงานอัตโนมัติ

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>

โหมด TSM เท่านั้น

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

การใช้งานพื้นฐานของโหนดหลายโหนด

โหนดเริ่มต้น

ตัวเลือกที่ 1: ใช้ตัวเลือกนี้หากการกำหนดค่าเซิร์ฟเวอร์ (CONFIG_FILE) ระบุโทโพโลยีแบบหลายโหนด:

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>

ตัวเลือกที่ 2: ใช้ตัวเลือกนี้หากคุณต้องการปรับใช้หลายโหนดแม้การกำหนดค่าเซิร์ฟเวอร์จะไม่ได้ระบุโทโพโลยีแบบหลายโหนดก็ตาม:

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>

โหนดเพิ่มเติม

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>

ทำให้การใช้งานข้อมูลเป็นภายนอก

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>

การใช้งานพื้นฐานของคอนเทนเนอร์เริ่มต้น

คอนเทนเนอร์เริ่มต้น

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>

เรียกใช้คอนเทนเนอร์

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>

การคืนค่าพื้นฐานจากโหนดเดี่ยวที่สำรองไว้

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>