--- schema_version: "1" id: 5f50002093b53ad8a6dce3ff5dcc78762e3907167b78efe92cb32b8f28410082 title: Tableau Server ในคอนเทนเนอร์ - การใช้อิมเมจ collection: tableau version: current locale: th-th portal_url: https://docs.salesforce.com/tableau/current/th-th/server-linux/server-in-container_image.md canonical_url: https://help.tableau.com/current/server-linux/th-th/server-in-container_image.htm source_site: help.tableau.com content_type: documentation content_hash: 1b15698c2c48847a084170fd147ea14373d837890ddae5a51f79e3c164dcee68 description: Run Tableau Server in a container using a Docker image. --- [ข้ามไปยังเนื้อหาหลัก](#main-content) # Tableau Server ในคอนเทนเนอร์ - การใช้อิมเมจ ## บทนำ Tableau Server ในคอนเทนเนอร์เป็นการเสนอบริการเซิร์ฟเวอร์ที่ใช้คอนเทนเนอร์เป็นหลักครั้งแรกของ Tableau Tableau Server ในคอนเทนเนอร์เป็นอินสแตนซ์ Tableau Server แบบครบวงจรที่ทำงานอยู่ในคอนเทนเนอร์ Linux Docker กล่าวอีกแง่หนึ่งคืออิมเมจ Tableau Server ในคอนเทนเนอร์เป็นอิมเมจ Docker ที่ใช้แอปพลิเคชัน Tableau Server ทั้งหมดด้วยตนเอง Tableau Server ในคอนเทนเนอร์เป็นหนึ่งในขั้นตอนมากมายของเราในการสนับสนุน Tableau Server ที่ทำงานในสภาพแวดล้อมที่ใช้คอนเทนเนอร์เป็นหลัก วิธีที่ง่ายที่สุดที่จะทำความเข้าใจแนวคิดของ Tableau Server ในคอนเทนเนอร์คือเสมือนว่าเป็นเครื่องเสมือน (VM) ที่มี Tableau Server ติดตั้งมาแล้วล่วงหน้า อิมเมจจะอิงตามอิมเมจ UBI 8 และเรียกใช้ `supervisord` (แทนที่ `systemd`) ในคอนเทนเนอร์ เมื่อคอนเทนเนอร์เริ่มใช้งาน `supervisord` ระบบจะพยายามเริ่มต้นใช้งานและเปิดใช้ Tableau Server ทันที เอกสารส่วนใหญ่ ณ ที่นี้มุ่งหวังที่จะอธิบายวิธีการกำหนดค่าและใช้ประโยชน์จากกระบวนการอัตโนมัติเพื่อที่คุณจะสามารถเรียกใช้ Tableau Server ในสภาพแวดล้อม Docker ได้ เครื่องมือการตั้งค่าอิมเมจของ Tableau Server ในคอนเทนเนอร์จะช่วยให้คุณสร้างและปรับแต่งอิมเมจคอนเทนเนอร์ให้รวมแพ็กเกจและอาร์ติแฟกต์ที่กำหนดเอง หนึ่งในฟังก์ชันหลักของเครื่องมือคือการสร้างอิมเมจคอนเทนเนอร์และติดตั้งเครื่องมือเชื่อมต่อข้อมูลที่กำหนดเอง หากต้องการทดสอบอิมเมจ Tableau Server ในคอนเทนเนอร์อย่างรวดเร็วในลักษณะของการพิสูจน์แนวคิด ให้ดูที่ [เริ่มต้น Tableau Server ในคอนเทนเนอร์](https://help.tableau.com/current/server-linux/th-th/server-in-container_quickstart.htm) ## ข้อจำกัดของ Tableau Server ในคอนเทนเนอร์ - Tableau Server ในคอนเทนเนอร์รองรับเฉพาะการเปิดใช้งานใบอนุญาตโดยใช้ Server ATR เท่านั้น ไม่รองรับการเปิดใช้งานแบบออฟไลน์ - ปัจจุบัน 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 ### การเรียกใช้อิมเมจ หากต้องการใช้ Docker อิมเมจของ Tableau Server ในคอนเทนเนอร์ คำสั่งที่ง่ายที่สุดที่จะเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์มีดังนี้ docker run \\ -e LICENSE\_KEY= -p 8080:8080 -d ขั้นตอนนี้จะเรียกใช้ Docker ในเบื้องหลังและหลังจากนั้นครู่หนึ่ง จะส่งผลให้อินสแตนซ์ของ Tableau Server ติดตั้งอย่างสมบูรณ์ Tableau Server อาจใช้เวลาเริ่ม 10 ถึง 20 นาที ขึ้นอยู่กับฮาร์ดแวร์ของคอมพิวเตอร์ที่เรียกใช้อิมเมจ คุณสามารถยืนยันว่าคอนเทนเนอร์กำลังทำงานได้โดยพิมพ์คำสั่ง `docker ps` เมื่อ Tableau Server ทำงาน คุณจะต้องสร้างบัญชีผู้ดูแลระบบ Tableau Server เริ่มต้น ขั้นตอนนี้อาจดำเนินการอัตโนมัติ หากต้องการข้อมูลเพิ่มเติม โปรดดู[สร้างผู้ดูแลระบบ Tableau Server คนแรกโดยอัตโนมัติ](#AutomateInitAdmin) #### สรุปอาร์กิวเมนต์การเรียกใช้ขั้นพื้นฐาน ตัวเลือกทั้งหมดที่ใช้ในคำสั่งการเรียกใช้ Docker ล้วนเป็นตัวเลือกที่จำเป็น และบ่อยครั้งก็จะมีตัวเลือกเพิ่มเติมเพื่อประโยชน์ในการใช้ฟังก์ชันการทำงานต่างๆ ในภาพ สำหรับตอนนี้ เราจะดูเฉพาะอาร์กิวเมนต์ที่ใช้ในคำสั่งเรียกใช้ Docker ที่ง่ายที่สุดสำหรับ Tableau Server ในคอนเทนเนอร์: | อาร์กิวเมนต์ | คำอธิบาย | | --- | --- | | \-e LICENSE\_KEY= | Tableau Server ต้องได้รับสิทธิ์อนุญาต ตัวแปรสภาพแวดล้อมนี้จะจัดเก็บคีย์ที่จะใช้เพื่อให้สิทธิ์อนุญาตเซิร์ฟเวอร์ ซึ่งเป็นองค์ประกอบที่จำเป็นของกระบวนการเริ่มต้น คุณสามารถระบุสิทธิ์อนุญาตหลายสิทธิ์ได้ โดยคั่นด้วยเครื่องหมายจุลภาค | | \-p 8080:8080 | ซึ่งจะบอกให้ Docker เปิดพอร์ต 8080 ภายในคอนเทนเนอร์และผูกเข้ากับพอร์ต 8080 ในเครื่องโฮสต์ ค่า 8080 แรกเป็นค่าที่สามารถกำหนดค่าได้ การเปลี่ยนแปลงค่านี้จะแก้ไขพอร์ตที่แมปกับโฮสต์ ตามค่าเริ่มต้นแล้ว Tableau Server คาดว่าผู้ใช้จะรับส่งข้อมูลผ่านเครือข่ายบนพอร์ต 8080 ภายในคอนเทนเนอร์ คุณสามารถเลือกได้ว่าจะเปิดพอร์ตนี้บนพอร์ตของโฮสต์อื่นๆ หรือไม่เปิดเลยก็ได้ | ### สร้างผู้ดูแลระบบ Tableau Server คนแรกโดยอัตโนมัติ เมื่อเริ่มต้นใช้งาน Tableau Server เป็นครั้งแรก จะต้องสร้างผู้ใช้ที่เป็นผู้ดูแลระบบเริ่มต้นขึ้นก่อนจึงจะอนุญาตการเชื่อมต่อเครือข่ายทางไกลเข้ากับ Tableau Server ซึ่งสามารถทำได้โดยเรียกใช้คำสั่ง `tabcmd initialuser -s localhost:8080 -u -p ` ภายในคอนเทนเนอร์ คุณสามารถตั้งค่าข้อมูลประจำตัวของผู้ดูแลระบบผ่านตัวแปรสภาพแวดล้อมได้ด้วย `TABLEAU_USERNAME` และ `TABLEAU_PASSWORD` หรือ `TABLEAU_PASSWORD_FILE` (แนะนำ) คือตัวแปรสภาพแวดล้อมที่สามารถตั้งค่าให้ส่งผ่านข้อมูลเข้าสู่ระบบของผู้ดูแลระบบเริ่มต้นได้ หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการจัดการรหัสผ่าน โปรดดู [การจัดการรหัสผ่าน](#PasswordManagement) หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับคำสั่ง `tabcmd initialuser` โปรดดู [initialuser](https://help.tableau.com/current/server-linux/th-th/tabcmd_cmd.htm#initialu) ตัวอย่าง docker run \\ -e LICENSE\_KEY= \\ -e TABLEAU\_USERNAME= \\ -e TABLEAU\_PASSWORD\_FILE=/etc/tableau-admin-secret \\ -v :/etc/tableau-admin-secret \\ -p 8080:8080 -d ### การให้สิทธิ์อนุญาต #### การให้สิทธิ์อนุญาตในคอนเทนเนอร์ การให้สิทธิ์อนุญาต Tableau Server ในคอนเทนเนอร์จะใช้บริการให้สิทธิ์เรียกใช้ (ATR) ของเซิร์ฟเวอร์เพื่อเปิดใช้งาน Tableau Server ที่ปรับใช้ในระบบคลาวด์ หรือสภาพแวดล้อมเสมือน โดยไม่ต้องเรียกใช้การปิดใช้งานสิทธิ์อนุญาต บริการ ATR สามารถทำขั้นตอนนี้ได้โดยให้สัญญาเช่าระยะสั้นของระยะเวลาที่กำหนดได้ (ระยะเวลา ATR) จนกว่าจะถึงวันหมดอายุของคีย์ผลิตภัณฑ์ ATR จะสรุปการให้สิทธิ์อนุญาตของ Tableau จากการเปลี่ยนแปลงฮาร์ดแวร์เบื้องหลัง ซึ่งเป็นแง่มุมพื้นฐานของการปรับใช้คอนเทนเนอร์ เนื่องจาก ATR ของเซิร์ฟเวอร์กำหนดให้คอนเทนเนอร์ต้องเข้าถึงบริการ ATR ที่ Tableau โฮสต์ได้ ดังนั้นคอนเทนเนอร์จึงจำเป็นต้องเชื่อมต่ออินเทอร์เน็ต Tableau Server ในคอนเทนเนอร์ไม่รองรับการเปิดใช้งานแบบออฟไลน์หรือด้วยตนเอง หากต้องการข้อมูลเพิ่มเติม โปรดดู [เปิดใช้งาน Tableau Server ด้วยบริการให้สิทธิ์การใช้งาน (Authorization-To-Run (ATR))](https://help.tableau.com/current/server-linux/th-th/atr_service.htm) **สำคัญ:** คุณต้องระบุตัวแปรสภาพแวดล้อม `LICENSE_KEY` หรือ `LICENSE_KEY_FILE` (เพียงชุดเดียว) เมื่ออัปเกรด Tableau Server ในคอนเทนเนอร์ หากคุณมีจำนวนสิทธิ์อนุญาตจนถึงขีดจำกัดสูงสุดแล้ว Tableau Server จะไม่สามารถเริ่มได้จนกว่าระยะเวลา ATR จะผ่านไป (4 ชั่วโมง/14400 วินาทีตามค่าเริ่มต้น) หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าหรือเปลี่ยนแปลงระยะเวลา ATR โปรดดู [เปิดใช้งาน Tableau Server ด้วยบริการให้สิทธิ์การใช้งาน (Authorization-To-Run (ATR))](https://help.tableau.com/current/server-linux/th-th/atr_service.htm) ##### ตัวแปรสภาพแวดล้อมการให้สิทธิ์อนุญาต Tableau Server ในคอนเทนเนอร์รองรับการตั้งค่าคีย์ใบอนุญาตโดยใช้ตัวแปรสภาพแวดล้อม โดย `LICENSE_KEY` จะมีคีย์ได้ตั้งแต่หนึ่งคีย์ขึ้นไป (-e LICENSE\_KEY=" , ") โดยใช้เครื่องหมายจุลภาคคั่นในรายการ ตัวอย่าง docker run \\ -e LICENSE\_KEY=", " \\ -p 8080:8080 -d #### ไฟล์สิทธิ์อนุญาต Tableau Server ในคอนเทนเนอร์รองรับการตั้งค่าคีย์ผลิตภัณฑ์โดยใช้ไฟล์ด้วยเช่นกัน ต่อเชื่อมไฟล์กับตำแหน่งไฟล์คีย์สิทธิ์อนุญาตตามค่าเริ่มต้นในคอนเทนเนอร์ (`/docker/config/license_file`) หรือตามที่ระบุโดยตัวแปรสภาพแวดล้อม `LICENSE_KEY_FILE` ตัวอย่าง docker run \\ -v :/docker/config/license\_file \\ -p 8080:8080 -d #### ระยะเวลาการเช่าสิทธิ์อนุญาตที่ร้องขอ คุณสามารถระบุเวลาการเช่าสิทธิ์อนุญาต ATR ในคอนเทนเนอร์ Tableau Server ได้ โดยการตั้งค่าตัวแปรสภาพแวดล้อม `REQUESTED_LEASE_TIME` คุณต้องระบุเวลาการเช่าเป็นวินาที โดยระยะเวลาขั้นต่ำคือ 3600 วินาที (หรือ 1 ชั่วโมง) ขอแนะนำให้คุณลดเวลาการเช่าลงเมื่อทำการทดลองและทดสอบ Tableau Server เพื่อลดโอกาสที่จะถึงขีดจำกัดสูงสุดของการเช่าที่เปิดใช้งาน สำหรับการปรับใช้ในสภาพแวดล้อมจริง ขอแนะนำเป็นอย่างยิ่งว่าไม่ควรกำหนดพารามิเตอร์ `REQUESTED_LEASE_TIME` (ใช้เป็นค่าเริ่มต้น) เพื่อให้ Tableau สามารถกำหนดเวลาการเช่าที่เหมาะสมได้ ตัวอย่าง docker run \\ ... -e REQUESTED\_LEASE\_TIME= \\ -p 8080:8080 -d ### การเรียกใช้อิมเมจที่ยังไม่ได้เริ่ม 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 ในคอนเทนเนอร์แล้ว คุณจะสามารถเรียก TSM และใช้คำสั่ง tabcmd ได้โดยตรง โดยเครื่องมือเหล่านี้จะเพิ่มลงในเส้นทางสภาพแวดล้อมโดยตรงของผู้ใช้ pid 1 ราย (ซึ่งได้รับสิทธิ์รูทในขณะนี้) จึงหมายความว่า คุณสามารถเรียก TSM และคำสั่ง tabcmd ได้ดังนี้ docker exec -it tsm status -v docker exec -it tabcmd initialuser -s localhost -u -p และยังสามารถเปิดเชลล์ในคอนเทนเนอร์เพื่อดำเนินการงานทั่วไปได้มากขึ้น เราไม่แนะนำขั้นตอนนี้ในสถานการณ์ทั่วไป ยกเว้นเพื่อจุดประสงค์ในการแก้ไขข้อบกพร่อง docker exec -it 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](https://help.tableau.com/current/server-linux/th-th/sign_in_tsm.htm) #### การสร้างผู้ใช้ระยะไกลของ 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= -v {absolute-path}/remote-user-secret:/docker/config/remote-user-secret -p 8080:8080 \\ -p 8850:8850 \\ -d ##### ตัวแปรสภาพแวดล้อม คุณสามารถตั้งเพียงแค่ตัวแปรสภาพแวดล้อม `TSM_REMOTE_PASSWORD` เมื่อเริ่มอิมเมจ Docker ได้ ตัวอย่างคำสั่งการเรียกใช้ Docker: docker run \\ -e LICENSE\_KEY= -e TSM\_REMOTE\_PASSWORD= -p 8080:8080 \\ -p 8850:8850 \\ -d หมายเหตุเพื่อความปลอดภัย - ต้องเปิดพอร์ต 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 อย่างไร เราจะอธิบายชุดย่อยของตัวแปรเหล่านี้ให้ละเอียดยิ่งขึ้น ค่าทั้งหมดเหล่านี้ได้รับการออกแบบให้ถูกแทนที่ เพื่อความยืดหยุ่นมากขึ้นสำหรับการกำหนดค่า
ชื่อสภาพแวดล้อมค่าเริ่มต้นคำอธิบาย
ACCEPTEULA0จะตั้งเป็น 1 โดยอัตโนมัติเมื่อสร้างอิมเมจขึ้นโดยใช้ Tableau Server ในเครื่องมือการตั้งค่าคอนเทนเนอร์
LICENSE_KEY กำหนดคีย์ผลิตภัณฑ์ที่จะใช้เพื่อให้สิทธิ์อนุญาตเซิร์ฟเวอร์ ยอมรับสิทธิ์อนุญาตหลายสิทธิ์โดยคั่นด้วยเครื่องหมายจุลภาค
LICENSE_KEY_FILE/docker/config/license_file เส้นทางไฟล์ไปยังไฟล์สิทธิ์อนุญาต รูปแบบของไฟล์สิทธิ์อนุญาตควรมีหนึ่งคีย์ผลิตภัณฑ์ต่อบรรทัด
REGISTRATION_FILE/docker/config/tableau_reg.jsonเส้นทางไฟล์ไปยังไฟล์การลงทะเบียนภายในอิมเมจ ตามค่าเริ่มต้นจะมีการให้ข้อมูลการลงทะเบียนเอาไว้เมื่อสร้างอิมเมจ Tableau Server ในคอนเทนเนอร์ ซึ่งสามารถเขียนทับได้ที่รันไทม์ หากต้องการข้อมูลเพิ่มเติม โปรดดู เปิดใช้งานและลงทะเบียน Tableau Server
REGISTRATION_DATA วิธีอื่นในการเขียนทับข้อมูลการลงทะเบียนขณะที่รันไทม์ ต้องกำหนดตัวแปรสภาพแวดล้อมนี้เป็นสตริง JSON แบบอนุกรมที่มีข้อมูลการลงทะเบียนเดียวกันกับที่พบในไฟล์การลงทะเบียน Tableau Server หากต้องการข้อมูลเพิ่มเติม โปรดดู เปิดใช้งานและลงทะเบียน Tableau Server
TABLEAU_USERNAME หมายถึงบัญชีผู้ดูแลระบบเริ่มต้นสำหรับ Tableau Server เป็นตัวแปรที่แนะนำ แต่ไม่บังคับ หากไม่ได้ตั้งค่าผู้ใช้รายนี้เป็นบัญชีผู้ดูแลระบบเริ่มต้นสำหรับ Tableau Server จะต้องตั้งค่าโดยใช้ tabcmd หากตั้งค่าตัวแปรนี้เป็นค่า ก็จำเป็นต้องมีรหัสผ่านด้วย โดยจะใช้เฉพาะเมื่อเริ่มใช้ Tableau Server เป็นครั้งแรก การตั้งค่านี้จะบอกให้ Tableau Server ในคอนเทนเนอร์พยายามเริ่มต้นผู้ใช้โดยอัตโนมัติ หากต้องการข้อมูลเพิ่มเติม โปรดดู เพิ่มบัญชีผู้ดุแลระบบ
TABLEAU_PASSWORD รหัสผ่านที่เป็นข้อความธรรมดาสำหรับผู้ใช้ Tableau หมายถึงบัญชีผู้ดูแลระบบเริ่มต้นสำหรับ Tableau Server ต้องมีข้อมูลนี้ หากมีการระบุ TABLEAU_USERNAME หากต้องการข้อมูลเพิ่มเติม โปรดดู เพิ่มบัญชีผู้ดุแลระบบ
TABLEAU_PASSWORD_FILE เส้นทางไฟล์ที่มีเฉพาะข้อความรหัสผ่านสำหรับผู้ใช้ Tableau หมายถึงบัญชีผู้ดูแลระบบเริ่มต้นสำหรับ Tableau Server ต้องมีข้อมูลนี้ หากมีการระบุ TABLEAU_USERNAME หากต้องการข้อมูลเพิ่มเติม โปรดดู เพิ่มบัญชีผู้ดุแลระบบ
CONFIG_FILE/docker/config/config.json

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

ไม่ต้องตั้ง CONFIG_DATA หากใช้ CONFIG_FILE

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

ตัวอย่าง CONFIG_DATA="{\"configEntities\":{\"identityStore\":{\"_type\":\"identityStoreType\",\"type\":\"local\"}}}" หากต้องการข้อมูลเพิ่มเติม โปรดดู ตัวอย่างไฟล์การกำหนดค่า

ไม่ต้องตั้ง CONFIG_FILE หากใช้ CONFIG_DATA

IGNORE_TOPOLOGY_CONFIG00 หรือ 1 หากตั้งเป็น 1 คอนเทนเนอร์จะละเว้นการกำหนดค่าที่เกี่ยวข้องกับโทโพโลยีใดๆ ที่มีอยู่ในไฟล์การกำหนดค่าที่ CONFIG_FILE กำหนด
BACKUP_FILE/docker/config/backup/backup-file.tsbakเส้นทางไฟล์ไปยังไฟล์ข้อมูลสำรองของ Tableau Server (.tsbak) หากระบุไว้ในระหว่างการเริ่มต้น เซิร์ฟเวอร์จะพยายามกู้คืน ต้องมีการจัดสรร IDENTITY_STORE_FILE ไว้ด้วย
IDENTITY_STORE_FILE/docker/config/identity-store-config.json ไฟล์การกำหนดค่าการระบุตัวตนในระหว่างการเรียกคืนจากไฟล์สำรองข้อมูล
INIT_CONTAINER00 หรือ 1 หากตั้งค่าเป็น 1 Tableau Server จะพยายามเริ่มต้น TSM และเริ่มต้น Tableau Server เท่านั้น และคอนเทนเนอร์ปิดการทำงานเมื่อเสร็จสิ้น
TSM_ONLY00 หรือ 1 เทียบเท่ากับการติดตั้ง Tableau Server rpm และเรียกใช้ initialize-tsm เฉพาะบริการ TSM (Tableau Service Manager) เท่านั้นที่จะเริ่มต้น ใช้งานได้เฉพาะเมื่อคอนเทนเนอร์กำลังเริ่มต้นเป็นครั้งแรกเท่านั้น (จะไม่ทำงานหาก Tableau Server ในคอนเทนเนอร์กำลังเริ่มต้นด้วยไดเรกทอรีเซิร์ฟเวอร์ที่เริ่มไปแล้วก่อนหน้านี้)
BOOTSTRAP_INSTALL00 หรือ 1 ระบุว่าเซิร์ฟเวอร์เป็นโหนดเริ่มต้นหรือโหนดเพิ่มเติม หากตั้งค่าเป็น 1 คอนเทนเนอร์จะรออย่างไม่มีกำหนดจนกว่าไฟล์บูตสแตรปจะอยู่ที่ตำแหน่งที่ $BOOTSTRAP_FILE ระบุ
ALWAYS_WRITE_BOOTSTRAP_FILE0 0 หรือ 1 หากตั้งเป็น 1 คอนเทนเนอร์จะเขียนไฟล์บูตสแตรปในตำแหน่งที่ระบุใน BOOTSTRAP_FILE
WAIT_FOR_BOOTSTRAP_FILE10 หรือ 1 หากตั้งค่าเป็น 1 (ค่าเริ่มต้น) หากตรวจพบคอนเทนเนอร์ แสดงว่าเป็นการติดตั้งโดยผู้ปฏิบัติงาน (BOOTSTRAP_INSTALL=1) คอนเทนเนอร์จะรออย่างไม่มีกำหนดจนกว่าจะตรวจพบไฟล์อยู่ในเส้นทางที่กำหนดใน BOOTSTRAP_FILE หากตั้งค่าเป็น 0 เมื่อเรียกใช้กระบวนการเริ่มต้น ระบบจะข้ามการรอนี้ ซึ่งเหมาะสำหรับกรณีแก้ไขข้อบกพร่องบางอย่าง
BOOTSTRAP_FILE/docker/config/bootstrap/bootstrap.jsonเส้นทางไฟล์ไปยังไฟล์บูตสแตรป มีผลเฉพาะกับคอนเทนเนอร์ของผู้ปฏิบัติงานเท่านั้น ไฟล์นี้ควรชี้ไปที่ไฟล์บูตสแตรปเท่านั้น การใช้งานทั่วไปคือการติดตั้งไดเร็กทอรีของไฟล์เป้าหมาย (ค่าเริ่มต้นคือ /docker/config/bootstrap) ไปที่โฮสต์
BOOTSTRAP_DATAสามารถใช้แทน BOOTSTRAP_FILE ได้ หากคุณต้องการเตรียมไฟล์บูตสแตรปโดยไม่ต้องต่อเชื่อมไฟล์ภายนอก ให้กำหนดตัวแปรสภาพแวดล้อมนี้เป็นเนื้อหาต่อเนื่องที่เทียบเท่ากันของไฟล์บูตสแตรป TSM ไม่ต้องตั้ง BOOTSTRAP_DATA หากใช้ BOOTSTRAP_FILE
PORT_RANGE_MIN8800 เราขอแนะนำให้เปิดเพียง 200 พอร์ต (8800-9000) แทนช่วงพอร์ต 8000-9000 เริ่มต้นของ Tableau Server ในองค์กรเพื่อเหตุผลด้านประสิทธิภาพ เนื่องจากการเปิดพอร์ต 1,000 พอร์ตใน Docker อาจส่งผลเสียต่อเวลาเริ่มต้นของอิมเมจ Docker ดูข้อมูลเพิ่มเติมที่การเปิดสิทธิ์อนุญาตและพอร์ต TSM ทางด้านล่าง
PORT_RANGE_MAX9000เราขอแนะนำให้เปิดเพียง 200 พอร์ต (8800-9000) แทนช่วงพอร์ต 8000-9000 เริ่มต้นของ Tableau Server ในองค์กร เนื่องจากการเปิดพอร์ต 1,000 พอร์ตใน Docker อาจส่งผลเสียต่อเวลาเริ่มต้นของอิมเมจ Docker ดูข้อมูลเพิ่มเติมที่การเปิดสิทธิ์อนุญาตและพอร์ต TSM ทางด้านล่าง
HTTP_PROXY หากต้องการส่งต่อคำขอ http ไปยังเซิร์ฟเวอร์พร็อกซี ให้กำหนดตัวแปรสภาพแวดล้อมนี้ให้ชี้ไปที่โฮสต์พร็อกซีของคุณ ยกตัวอย่างเช่น หากต้องการตั้งพร็อกซีไปที่โฮสต์ตัวอย่างของพอร์ต 8080 HTTP_PROXY=http://example-host:8080/
HTTPS_PROXY หากต้องการส่งต่อคำขอ https ไปยังเซิร์ฟเวอร์พร็อกซี ให้กำหนดตัวแปรสภาพแวดล้อมนี้ให้ชี้ไปที่โฮสต์พร็อกซีของคุณ ยกตัวอย่างเช่น หากต้องการตั้งพร็อกซีไปที่โฮสต์ตัวอย่างของพอร์ต 443, HTTPS_PROXY=http://example-host:443/ ตรวจดูว่าคุณใช้ 'http' เมื่อระบุ URL ของตัวแปรสภาพแวดล้อม HTTPS_PROXY
NO_PROXY หากต้องการข้ามเซิร์ฟเวอร์พร็อกซี ให้ระบุข้อยกเว้นในตัวแปร no_proxy ใช้ตัวแปรนี้หากเซิร์ฟเวอร์พร็อกซีของคุณไม่ได้กำหนดเส้นทางที่อยู่ภายใน ทั้งนี้คุณต้องเพิ่มข้อยกเว้นสำหรับการกำหนดค่าพร็อกซีนี้เพื่อรับประกันว่าการสื่อสารทุกช่องทางภายในคลัสเตอร์ Tableau Server ในเครื่อง (ที่คุณมีอยู่แล้วหรือต้องการให้มีในอนาคต) ไม่กำหนดเส้นทางไปยังเซิร์ฟเวอร์พร็อกซี ป้อนทั้งชื่อโฮสต์และที่อยู่ IP สำหรับคอมพิวเตอร์แต่ละเครื่อง แล้วเพิ่มชื่อโฮสต์ของคอนเทนเนอร์ นอกจากนี้ ให้ระบุชื่อโฮสต์ที่เป็นมาตรฐาน (โฮสต์ภายใน) และที่อยู่ IP (127.0.0.1) สำหรับคอมพิวเตอร์ในระบบ ยกตัวอย่างเช่น หากต้องการระบุข้อยกเว้นสำหรับคลัสเตอร์แบบสามโหนด: NO_PROXY="localhost,127.0.0.1,hostname1,hostname2,hostname3,IP1,IP2,IP3"
COORDINATION_SERVICE_CLIENT_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ตไคลเอ็นต์สำหรับบริการรวม
COORDINATION_SERVICE_PEER_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ตเพียร์สำหรับบริการร่วม
COORDINATION_SERVICE_LEADER_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ตลีดเดอร์สำหรับบริการร่วม
LICENSE_SERVICE_VENDOR_DAEMON_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ตเวนเดอร์ดีมอนสำหรับบริการให้สิทธิ์อนุญาต
AGENT_FILE_TRANSFER_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ตการถ่ายโอนไฟล์สำหรับบริการเอเจนต์
CONTROLLER_PORTพอร์ตใดๆ ระหว่าง PORT_RANGE_MIN กับ PORT_RANGE_MAX พอร์ต https สำหรับบริการตัวควบคุม
REQUESTED_LEASE_TIMEค่าเริ่มต้นในปัจจุบันตั้งเอาไว้ที่ 4 ชั่วโมงกำหนดเวลาเช่าสำหรับการเปิดใช้งาน ATR ของเซิร์ฟเวอร์ คุณต้องระบุค่าเวลา และเวลาขั้นต่ำคือ 14400 วินาที (หรือ 4 ชั่วโมง) โดยทั่วไปเราไม่แนะนำให้เปลี่ยนค่านี้สำหรับการปรับใช้ในสภาพแวดล้อมการใช้งานจริง แต่เมื่อมีการพัฒนาหรือสร้างต้นแบบด้วย Tableau Server ในคอนเทนเนอร์ คุณอาจต้องตั้งค่านี้ให้เป็นค่าต่ำสุดเพื่อลดการเสียการเปิดใช้งาน
#### ตัวแปรสภาพแวดล้อม Randomly นี่คือคุณสมบัติสภาพแวดล้อมที่อธิบายคุณสมบัติพื้นฐานบางอย่างของอิมเมจ Tableau Server ในคอนเทนเนอร์ เราไม่แนะนำให้แทนที่ค่าเหล่านี้ | ชื่อสภาพแวดล้อม | ค่าเริ่มต้น | คำอธิบาย | | --- | --- | --- | | PRE\_INIT\_COMMAND\_SCRIPT | `${DOCKER_CONFIG}/customer-files/pre_init_command` | เส้นทางไปยังไฟล์ bash/executable ที่กำหนดเองของผู้ใช้ ซึ่งจะใช้ทำงานใน Tableau Server ก่อนการเริ่มต้น Tableau Server **หมายเหตุ:** ตรวจสอบว่าไฟล์มีสิทธิ์การเรียกใช้งานสำหรับผู้ใช้ทุกคน ไม่เช่นนั้นให้เรียกใช้ `chmod +rx ` | | POST\_INIT\_COMMAND\_SCRIPT | `${DOCKER_CONFIG}/customer-files/post_init_command` | เส้นทางไปยังไฟล์ bash/executable ที่กำหนดเองของผู้ใช้ ซึ่งจะใช้ทำงานใน Tableau Server หลังจากที่เซิร์ฟเวอร์ทำงานอย่างเต็มที่ **หมายเหตุ:** ตรวจสอบว่าไฟล์มีสิทธิ์การเรียกใช้งานสำหรับผู้ใช้ทุกคน ไม่เช่นนั้นให้เรียกใช้ `chmod +rx ` | | DATA\_DIR | `/var/opt/tableau/tableau_server` | ไดเรกทอรีข้อมูลที่ควรเขียนบิตของ Tableau Server | | INSTALL\_DIR | `/opt/tableau/tableau_server` | ไดเรกทอรีข้อมูลที่เขียนบิตของ Tableau Server | | SERVICE\_NAME | `Tableau Server` | ชื่อของแอปพลิเคชันที่ทำงานอยู่ในคอนเทนเนอร์ | | SERVICE\_VERSION | ไม่ระบุ | เวอร์ชันของ Tableau Server ที่ติดตั้งในคอนเทนเนอร์ | | DOCKER\_CONFIG | `/docker` | ไดเรกทอรีที่เก็บการกำหนดค่าของ Docker ที่ระบุของ Tableau | | ENV\_FILE | `${DOCKER_CONFIG}/customer-files/environment` | ไฟล์ที่มีการแทนที่สภาพแวดล้อมของผู้ใช้ทั้งหมด | #### ตัวแปรสภาพแวดล้อมเวลาที่สร้าง |   |   |   | | --- | --- | --- | | BASE\_IMAGE\_URL | ใช้คำสั่งเครื่องมือการสร้าง: `build-image -b` | อิมเมจค่าเริ่มต้นที่ระบุในเครื่องมือสร้างอิมเมจและ Dockerfile เป็นอิมเมจฐานแบบเดียวที่รองรับอย่างเป็นทางการ พารามิเตอร์นี้สามารถนำไปใช้เพื่อดึงสำเนาของอิมเมจฐานที่เฉพาะเจาะจงนี้จากที่เก็บอิมเมจ Docker ที่กำหนดเอง หรือนิยามอิมเมจฐานที่กำหนดเองก็ได้ หากคุณเลือกใช้อิมเมจพื้นฐานที่กำหนดเอง ถือเป็นความรับผิดชอบของคุณที่จะต้องตรวจดูว่าอิมเมจอยู่บนพื้นฐานของ UBI 8 และมีทรัพยากรที่จำเป็นสำหรับเรียกใช้ Tableau Server อย่างเหมาะสม หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับอิมเมจพื้นฐานที่กำหนดเอง โปรดดู [Tableau Server ในคอนเทนเนอร์ - การใช้อิมเมจ](#DefiningCustomBaseImage-container) | | PRIVILEGED\_TABLEAU\_GID | `997` | GID ของกลุ่ม Tableau ที่ได้รับสิทธิ์ | | UNPRIVILEGED\_TABLEAU\_GID | `998` | GID ของกลุ่ม Tableau ที่ไม่ได้รับสิทธิ์ | | UNPRIVILEGED\_TABLEAU\_UID | `999` | UID ของผู้ใช้ที่เรียกใช้กระบวนการ Tableau (การปรับใช้ของผู้ใช้รายเดียว) | | UNPRIVILEGED\_USERNAME | `tableau` | ชื่อสตริงของผู้ใช้ที่ไม่ได้รับสิทธิ์ | | UNPRIVILEGED\_GROUP\_NAME | `tableau` | ชื่อสตริงของกลุ่มที่ไม่ได้รับสิทธิ์ | | PRIVILEGED\_GROUP\_NAME | `tsmadmin` | ชื่อสตริงของผู้ใช้ที่ได้รับสิทธิ์ | | LANG | `en_US.UTF-8` | การตั้งค่าภาษา | #### การแทนที่การกำหนดค่าของ Tableau Server Docker จะสามารถเขียนทับตัวแปรสภาพแวดล้อมเหล่านี้กับจุดที่ไฟล์ใดๆ ในคอนเทนเนอร์ได้ ดังนั้นคุณสามารถระบุจุดเชื่อมต่ออื่นได้ ในกรณีที่คุณต้องการ Tableau Server ต้องใช้ไฟล์การกำหนดค่าเพื่อเริ่มต้นและทำงาน: CONFIG\_FILE=/docker/config/config.json `CONFIG_FILE` จะอ้างอิงถึงไฟล์การกำหนดค่า TSM รูปแบบและการใช้งานจะเหมือนกับไฟล์การกำหนดค่าที่อธิบายใน[ตัวอย่างไฟล์การกำหนดค่า](https://help.tableau.com/current/server-linux/th-th/config_file_example.htm) #### คำสั่งก่อนการเริ่มต้นและหลังการเริ่มต้น 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 `) หรือสิทธิ์ความเป็นเจ้าของตรงกับผู้ใช้ที่ไม่ได้รับสิทธิ์ในคอนเทนเนอร์หรือไม่ #### การกำหนดค่าผู้ใช้ 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 :/etc/admin-secret \\ -d ###### ตัวอย่างเนื้อหาของไฟล์ข้อมูลลับ mypassword23879172 อีกทางหนึ่งสามารถจัดเก็บรหัสผ่านโดยตรงเป็นข้อความธรรมดาในตัวแปรสภาพแวดล้อมรหัสผ่าน วิธีนี้ถือว่ามีความปลอดภัยน้อยกว่า แต่มีความสะดวกมากกว่าและเป็นรูปแบบที่ใช้กันโดยทั่วไปกับคอนเทนเนอร์ ###### ตัวอย่าง docker run \\ ... -e TABLEAU\_USERNAME=admin \\ -e TABLEAU\_PASSWORD=password \\ -d ### การกำหนดค่า Tableau Server หลังจากที่ทำงาน เมื่อ Tableau Server เริ่มต้นและทำงานแล้ว วิธีการที่ดีที่สุดในการโต้ตอบกับเซิร์ฟเวอร์คือการใช้เครื่องมือ TSM CLI นี่คือเครื่องมือคลาสสิกของ Tableau Server ในการทำงานของผู้ดูแลระบบ ในอนาคต เราจะพัฒนาการโต้ตอบของ Tableau Server ให้สอดรับกับการเปลี่ยนแปลงในการกำหนดค่าแบบคงที่ที่ระบุในตัวแปรสภาพแวดล้อม `CONFIG_FILE` ในระหว่างการทำงาน แต่ในขณะนี้ หลังจากที่ Tableau Server เริ่มต้นแล้ว คุณจะต้องโต้ตอบกับเซิร์ฟเวอร์โดยใช้เครื่องมือคลาสสิก หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับบรรทัดคำสั่งของ TSM โปรดดู [ข้อมูลอ้างอิงบรรทัดคำสั่ง tsm](https://help.tableau.com/current/server-linux/th-th/tsm.htm) ### สถานะ มีการตรวจสอบสถานะพื้นฐานสำหรับ 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 :/var/opt/tableau \\ -e LICENSE\_KEY= \\ --hostname= \\ -p 8080:8080 -d ### สำรองข้อมูลและคืนค่า Tableau Server ในคอนเทนเนอร์รองรับ Tableau Server ที่สร้างการสำรองข้อมูลและคืนค่าจากไฟล์สำรองข้อมูล (.tsbak) ขั้นตอนแรกคือการเรียกใช้อิมเมจ Tableau Server ในคอนเทนเนอร์ เชื่อมต่อไฟล์สำรองข้อมูล (.tsbak) เข้ากับอิมเมจ แล้วตั้งตัวแปรสภาพแวดล้อม `BACKUP_FILE` กับเส้นทางไฟล์ไปยังไฟล์สำรองข้อมูล นอกจากนี้ คุณต้องจัดเตรียมไฟล์การกำหนดค่าในตัวแปรสภาพแวดล้อม `CONFIG_FILE` คอนเทนเนอร์ Tableau Server จะดำเนินกระบวนการคืนค่าโดยอัตโนมัติ แม้จะเป็นการปรับใช้แบบหลายโหนด หากระบบอัตโนมัตินี้ไม่สามารถกู้คืนระบบได้อย่างสมบูรณ์ไม่ว่าจะในขั้นตอนใด คุณสามารถย้อนกลับบนเครื่องมือและกระบวนการคลาสสิกของ Tableau Server ได้ เช่น ใช้คำสั่ง TSM เพื่อโต้ตอบกับ Tableau Server ในลักษณะเดียวกับที่คุณทำกับการปรับใช้ที่ไม่ใช่คอนเทนเนอร์ หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการสำรองข้อมูลและคืนค่าอินสแตนซ์มาตรฐานของ Tableau Server โปรดดู [ดำเนินการสำรองข้อมูลและกู้คืน Tableau Server อย่างเต็มรูปแบบ](https://help.tableau.com/current/server-linux/th-th/backup_restore.htm) #### สำรองข้อมูลในคอนเทนเนอร์ 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 .tsbak -d # Any filepath where current user(UNPRIVILEGED USER) can write. tsm settings export -f /var/opt/tableau/tableau\_server/data/tabsvc/files/backups/.json 2. คัดลอกไฟล์ที่สร้างขึ้นในขั้นตอนก่อนหน้าไปที่เครื่องโฮสต์ เปลี่ยนสิทธิ์ของทั้งสองไฟล์ให้มีสิทธิ์อ่านทั้งหมด docker cp my-server:/var/opt/tableau/tableau\_server/data/tabsvc/files/backups/.tsbak ./.tsbak docker cp my-server:/var/opt/tableau/tableau\_server/data/tabsvc/files/backups/.json ./.json chmod a+r ./.tsbak ./.json 3. จัดเก็บไฟล์การสำรองข้อมูลในพื้นที่ที่ปลอดภัย ดำเนินการตามขั้นตอนคืนค่าด้านล่างเมื่อต้องการ #### คืนค่าภายในคอนเทนเนอร์ของ Tableau Server คุณสามารถคืนค่าข้อมูลสำรองจากเวอร์ชัน Tableau Server ที่รองรับ (ทั้งแบบคอนเทนเนอร์และไม่ใช่คอนเทนเนอร์) ภายในคอนเทนเนอร์ Tableau Server ##### ข้อกำหนดเบื้องต้น - ไฟล์สำรองข้อมูล Tableau Server - ไฟล์การกำหนดค่า json ที่มีทั้งข้อมูลการกำหนดค่าและข้อมูลโทโพโลยี - ไฟล์ JSON การกำหนดค่าที่ประกอบด้วยข้อมูลที่เก็บข้อมูลประจำตัว - **หมายเหตุ:** คุณอาจต้องเปลี่ยนไฟล์สำรองข้อมูลเพื่อให้มีสิทธิ์การอ่านทั้งหมด โดยปกติแล้ว ไฟล์สำรองข้อมูลมักจะล็อกกับผู้ใช้ที่สร้างไฟล์ และน่าจะแตกต่างจากผู้ใช้ Tableau ที่ทำงานอยู่ในคอนเทนเนอร์ docker run \\ \-v :/docker/config/backup/backup-file.tsbak \\ \-v :/docker/config/config.json:ro \\ \-v :/docker/config/identity-store-config.json \\ \-e LICENSE\_KEY= \\ \-p 8080:8080 -d หมายเหตุ: - หากคุณกำลังคืนค่าให้ระบบแบบหลายโหนด คุณต้องเริ่มโหนดอื่นด้วย เพื่อให้ระบบคืนค่าอัตโนมัติทำงาน ดูข้อมูลเพิ่มเติมที่ส่วน[Tableau Server แบบหลายโหนดในคอนเทนเนอร์](#MultiNode-container)ของเอกสารนี้ เฉพาะโหนดแรกเท่านั้นที่ต้องการไฟล์ข้อมูลสำรอง ไฟล์การกำหนดค่าสำรอง และสิทธิ์อนุญาต - ต้องระบุเฉพาะไฟล์สำรองข้อมูลเท่านั้นในการเรียกใช้คอนเทนเนอร์ครั้งแรก เมื่อเริ่มต้นเซิร์ฟเวอร์แล้ว คุณไม่จำเป็นต้องเชื่อมต่อในไฟล์สำรองข้อมูลอีกต่อไป ### การย้ายจาก Tableau Server ไปที่ Tableau Server ในคอนเทนเนอร์ หากต้องการย้ายจากการติดตั้ง Tableau Server แบบมาตรฐานไปที่ Tableau Server ในคอนเทนเนอร์ คุณจะต้องใช้เทคนิคการสำรองข้อมูลและการคืนค่า คุณสามารถคืนค่าข้อมูลสำรองจากเวอร์ชัน Tableau Server ที่รองรับ (ทั้งแบบคอนเทนเนอร์และไม่ใช่คอนเทนเนอร์) ภายในคอนเทนเนอร์ Tableau Server ดูข้อมูลเพิ่มเติมที่ส่วน[คืนค่าภายในคอนเทนเนอร์ของ Tableau Server](#RestoreInside-container) ทางด้านบน ### การอัปเกรดเวอร์ชันของ Tableau Server การอัปเกรด Tableau Server มีสองวิธีดังนี้ วิธีการใช้อิมเมจอัปเกรดที่แสดงในส่วนนี้เป็นโซลูชันที่แนะนำ อย่างไรก็ตาม การอัปเกรด Tableau Server โดยใช้การสำรองข้อมูล/คืนค่า ก็เป็นวิธีสำรองที่สามารถใช้ได้เช่นกัน #### การอัปเกรดด้วยอิมเมจอัปเกรด อิมเมจอัปเกรดคืออิมเมจของ Docker ที่สามารถสร้างขึ้นโดยใช้สคริปต์ `build-upgrade-image` จากเครื่องมือการตั้งค่า Tableau Server ในคอนเทนเนอร์ จุดประสงค์ของอิมเมจนี้คือการอัปเกรด Tableau Server ในคอนเทนเนอร์ที่กำลังทำงานอยู่เท่านั้น **สําคัญ:** แม้ในขณะที่คุณใช้วิธี Upgrade-Image เราขอแนะนําให้คุณสํารองข้อมูล Tableau Server อย่างเต็มรูปแบบตามที่อธิบายไว้ใน[สำรองข้อมูลและคืนค่า](#Backup-container)ด้านบน วิธีนี้จะช่วยให้คุณมีตัวเลือกหากการอัปเกรดไม่สำเร็จไม่ว่าด้วยเหตุผลใดก็ตาม โปรดทำตามขั้นตอนด้านล่างนี้เพื่ออัปเกรด 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= -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 :/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 :/var/opt/tableau \\ ... ... tableau-server:versionB #### การอัปเกรดผ่านวิธีการสำรองข้อมูล-คืนค่า ทำตามขั้นตอนในส่วน[สำรองข้อมูลและคืนค่า](#Backup-container)ของเอกสารนี้ โดยเปลี่ยนขั้นตอนการคืนค่าข้อมูลสำรองเป็น Tableau Server เวอร์ชันใหม่ เพียงขั้นตอนเดียวในการสำรองข้อมูลและคืนค่า ### Tableau Server แบบหลายโหนดในคอนเทนเนอร์ Tableau Server แบบหลายโหนดในคอนเทนเนอร์คือการปรับใช้ Tableau Server ครั้งเดียวโดยกระจายไปในหลายโหนด คำว่าหลายโหนดในบริบทนี้เหมือนกับคำว่าหลายโหนดของ Tableau Server ซึ่งสามารถเรียกใช้กระบวนการบางอย่างบนโหนดอื่นๆ เพื่อเพิ่มความจุ กำลังประมวลผล ฯลฯ โดยจะแตกต่างจากการเริ่ม Tableau Server ในคอนเทนเนอร์หลายคอนเทนเนอร์แยกกัน และแต่ละคอนเทนเนอร์เป็นเซิร์ฟเวอร์อิสระที่มีข้อมูลที่แตกต่างกันเป็นของตนเอง Tableau Server แบบหลายโหนดในคอนเทนเนอร์จะทำงานเหมือนกับการติดตั้ง Tableau Server แบบหลายโหนดที่ไม่ใช้คอนเทนเนอร์ และจะใช้กลไกเบื้องหลังเหมือนกัน หากต้องการดูภาพรวมการตั้งค่าการติดตั้ง Tableau Server แบบหลายโหนดที่ไม่ใช้คอนเทนเนอร์ โปรดดู [การติดตั้ง Tableau Server แบบกระจายและมีความพร้อมใช้งานสูง](https://help.tableau.com/current/server-linux/th-th/distrib_ha.htm) ตัวอย่างมีดังนี้ #### การใช้งานพื้นฐานของโหนดหลายโหนด ##### โหนดเริ่มต้น **ตัวเลือกที่ 1:** ใช้ตัวเลือกนี้หากการกำหนดค่าเซิร์ฟเวอร์ (`CONFIG_FILE`) ระบุโทโพโลยีแบบหลายโหนด: docker run \\ -v :/docker/config/bootstrap \\ -v :/docker/config/config.json:ro \\ -e LICENSE\_KEY= \\ -p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \\ --hostname= \\ -d **ตัวเลือกที่ 2:** ใช้ตัวเลือกนี้หากคุณต้องการปรับใช้หลายโหนดแม้การกำหนดค่าเซิร์ฟเวอร์จะไม่ได้ระบุโทโพโลยีแบบหลายโหนดก็ตาม: docker run \\ -v :/docker/config/bootstrap \\ -e LICENSE\_KEY= -e ALWAYS\_WRITE\_BOOTSTRAP\_FILE=1 \\ -p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \\ --hostname= \\ -d ##### โหนดเพิ่มเติม docker run \\ -v :/docker/config/bootstrap \\ -e BOOTSTRAP\_INSTALL=1 \\ -p 8080:8080 -p 8800-9000:8800-9000 \\ --hostname= \\ -d #### การเปิดสิทธิ์อนุญาตและพอร์ต 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 หากต้องการข้อมูลเพิ่มเติม โปรดดู[กำหนดค่าไฟร์วอลล์ในเครื่อง](https://help.tableau.com/current/server-linux/th-th/config_firewall_linux.htm) #### การแก้ปัญหาชื่อโฮสต์ โหนดหลายโหนดของ 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 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 ปกติ นอกจากนี้ยังมาพร้อมกับข้อกำหนดเดียวกัน ซึ่งหมายความว่าการเพิ่มกระบวนการใหม่บนโหนดอาจต้องรีสตาร์ททั้งคลัสเตอร์ หากต้องการข้อมูลเพิ่มเติม โปรดดู [กำหนดค่าโหนด](https://help.tableau.com/current/server-linux/th-th/config_nodes.htm) ## ข้อควรพิจารณาสำหรับฟีเจอร์ของ 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 #### ส่งออกใบรับรอง 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 -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= -p 8080:8080 -d ##### การใช้งานพื้นฐานของ Tableau Server ในคอนเทนเนอร์พร้อมผู้ใช้ที่เป็นผู้ดูแลระบบเริ่มต้นที่ทำงานอัตโนมัติ docker run \\ -e LICENSE\_KEY= \\ -e TABLEAU\_USERNAME= \\ -e TABLEAU\_PASSWORD\_FILE=/etc/tableau-admin-secret \\ -v :/etc/tableau-admin-secret \\ -p 8080:8080 -d ##### โหมด TSM เท่านั้น docker run \\ -e TSM\_ONLY=1 \\ -p 8080:8080 -d ##### การใช้งานพื้นฐานของโหนดหลายโหนด ###### โหนดเริ่มต้น **ตัวเลือกที่ 1:** ใช้ตัวเลือกนี้หากการกำหนดค่าเซิร์ฟเวอร์ (`CONFIG_FILE`) ระบุโทโพโลยีแบบหลายโหนด: docker run \\ -v :/docker/config/bootstrap \\ -v :/docker/config/config.json:ro \\ -e LICENSE\_KEY= \\ -p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \\ --hostname= \\ -d **ตัวเลือกที่ 2:** ใช้ตัวเลือกนี้หากคุณต้องการปรับใช้หลายโหนดแม้การกำหนดค่าเซิร์ฟเวอร์จะไม่ได้ระบุโทโพโลยีแบบหลายโหนดก็ตาม: docker run \\ -v :/docker/config/bootstrap \\ -e LICENSE\_KEY= -e ALWAYS\_WRITE\_BOOTSTRAP\_FILE=1 \\ -p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \\ --hostname= \\ -d ###### โหนดเพิ่มเติม docker run \\ -v :/docker/config/bootstrap \\ -e BOOTSTRAP\_INSTALL=1 \\ -p 8080:8080 -p 8800-9000:8800-9000 \\ --hostname= \\ -d ##### ทำให้การใช้งานข้อมูลเป็นภายนอก docker run \\ -v :/var/opt/tableau \\ -e LICENSE\_KEY= \\ --hostname= \\ -p 8080:8080 -d ##### การใช้งานพื้นฐานของคอนเทนเนอร์เริ่มต้น **คอนเทนเนอร์เริ่มต้น** docker run \\ -v :/var/opt/tableau \\ -e LICENSE\_KEY= \\ -e INIT\_CONTAINER=1 \\ --hostname= \\ -p 8080:8080 -d **เรียกใช้คอนเทนเนอร์** docker run \\ -v :/var/opt/tableau \\ --hostname= \\ -p 8080:8080 -d ##### การคืนค่าพื้นฐานจากโหนดเดี่ยวที่สำรองไว้ docker run \\ -v :/docker/config/backup/backup-file.tsbak \\ -v :/docker/config/config.json:ro \\ -e LICENSE\_KEY= \\ -p 8080:8080 -d #### Docker-Compose version: '3.2' services: tableau-server: hostname: localhost volumes: - :/docker/config/tsm-commands:ro - :/docker/config/config.json:ro ports: - "8080:8080" image: ${IMAGE\_NAME} environment: - LICENSE\_KEY=