---
schema_version: "1"
id: 6c1a96949d2bff12d54a3a0a9a701730433d3db88d6ec75e102eb7119b4ba72d
title: ส่วนที่ 5 - การกำหนดค่าระดับของเว็บ
collection: tableau
version: next
locale: th-th
portal_url: https://docs.salesforce.com/tableau/next/th-th/guides/enterprise-deployment/edg_part5.md
canonical_url: https://help.tableau.com/v0.0/guides/enterprise-deployment/th-th/edg_part5.htm
source_site: help.tableau.com
content_type: documentation
content_hash: f17bcb068e31b9db5beb623a4470cbd7c7dfded0809d547cadd6c57ebfb8f183
description: "Part 5: configure the web tier with Tableau Server Independent Gateway and reverse proxies."
---
[ข้ามไปยังเนื้อหาหลัก](#main-content)

# ส่วนที่ 5 - การกำหนดค่าระดับของเว็บ

**หมายเหตุ**: Tableau จะไม่อัปเดตคู่มือการปรับใช้ในองค์กรอีกต่อไป แม้ว่าเรายังคงแนะนําสถาปัตยกรรมอ้างอิงที่อธิบายไว้ในที่นี้ว่าเป็นโมเดลการปรับใช้ที่ถูกต้องสําหรับ Tableau Server ใน AWS แต่ขั้นตอนการกําหนดค่าเฉพาะอาจมีการเปลี่ยนแปลงตั้งแต่การอัปเดตครั้งล่าสุด ควรตรวจสอบขั้นตอนเหล่านี้กับเอกสาร[ความช่วยเหลือล่าสุดของ Tableau Server](https://help.tableau.com/current/server/th-th/get_started_server.htm) เสมอ เพื่อให้มั่นใจในความถูกต้อง

ระดับของเว็บของสถาปัตยกรรมการอ้างอิงจะรวมอยู่ในส่วนประกอบต่อไปนี้

- ตัวจัดสรรภาระงานแอปพลิเคชันที่เชื่อมต่อกับเว็บซึ่งยอมรับคำขอ HTTPS จากไคลเอ็นต์ Tableau และสื่อสารกับเซิร์ฟเวอร์พร็อกซีแบบย้อนกลับ
- พร็อกซีแบบย้อนกลับ 
    - เราขอแนะนำให้ปรับใช้เกตเวย์อิสระของ Tableau Server
    - เราขอแนะนำให้ใช้เซิร์ฟเวอร์พร็อกซีอย่างต่ำ 2 เครื่องเพื่อให้เกิดการทำซ้ำและจัดการกับภาระงานของไคลเอ็นต์
    - รับการเข้าชม HTTPS จากตัวจัดสรรภาระงาน
    - รองรับเซสชันความต่อเนื่องสำหรับโฮสต์ Tableau
    - กำหนดค่าพร็อกซีสำหรับการจัดสรรภาระงานแบบสลับกันทำงานไปยัง Tableau Server แต่ละรายการที่ใช้กระบวนการเกตเวย์
    - จัดการคำขอการตรวจสอบสิทธิ์จาก IdP ภายนอก
- พร็อกซีแบบส่งต่อ: Tableau Server ต้องมีสิทธิ์เข้าถึงอินเทอร์เน็ตเพื่อการให้สิทธิ์อนุญาตและฟังก์ชันการจับคู่ คุณต้องกำหนดค่ารายการที่อนุญาตส่งต่อพร็อกซีให้กับ URL ของบริการ Tableau ดูหัวข้อ_การสื่อสารกับอินเทอร์เน็ต_ ([Linux](https://help.tableau.com/current/server-linux/th-th/plan_network.htm))
- การใช้งานบนเครือข่ายทั้งหมดที่เกี่ยวข้องกับไคลเอ็นต์อาจได้รับการเข้ารหัสผ่าน HTTPS:
    - ตัวจัดสรรภาระงานไคลเอ็นต์ถึงแอปพลิเคชัน
    - ตัวจัดสรรภาระงานแอปพลิเคชันเพื่อเซิร์ฟเวอร์พร็อกซีย้อนกลับ
    - เซิร์ฟเวอร์พร็อกซีถึง Tableau Server
    - ตัวจัดการการตรวจสอบสิทธิ์ที่เรียกใช้บนพร็อกซีย้อนกลับถึง IdP
    - Tableau Server ถึง IdP

### เกตเวย์อิสระของ Tableau Server

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

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

เกตเวย์อิสระจำเป็นต้องมีใบอนุญาต Advanced Management

## การตรวจสอบสิทธิ์และการให้สิทธิ์

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

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

### การตรวจสอบสิทธิ์ล่วงหน้าด้วยโมดูล AuthN

ในตัวอย่างที่ระบุในคู่มือนี้ เราจะกำหนดค่า SAML SSO แต่กระบวนการตรวจสอบล่วงหน้าจะสามารถกำหนดค่าผู้ให้บริการข้อมูลประจำตัวภายนอกส่วนส่วนใหญ่และโมดูล AuthN ได้

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

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

![ขั้นตอนที่แสดงในแผนภาพข้างบน ขั้นที่ 1: ไคลเอ็นต์ Tableau ส่งคำขอทรัพยากรบน Tableau Server ขั้นที่ 2: พร็อกซีย้อนกลับสร้างคำขอการตรวจสอบสิทธิ์โดยใช้การเปลี่ยนทิศ URL ไปที่ผู้ให้บริการข้อมูลประจำตัว ขั้นที่ 3: ผู้ให้บริการข้อมูลประจำตัวจะส่งแบบฟอร์มการเข้าสู่ระบบให้กับผู้ใช้ ขั้นที่ 4: ผู้ใช้จะได้รับข้อความแจ้งและป้อนข้อมูลเข้าสู่ระบบ ขั้นที่ 5: ผู้ให้บริการข้อมูลประจำตัวจะตรวจสอบข้อมูลเข้าสู่ระบบที่ผู้ใช้ส่ง ขั้นที่ 6: ผู้ให้บริการข้อมูลประจำตัวจะตอบกลับไคลเอ็นต์ด้วยการยืนยัน SAML ที่จะโพสต์ไปที่ผู้ให้บริการพร็อกซีย้อนกลับ ขั้นที่ 7: ผู้ให้บริการบนพร็อกซีจะตรวจสอบการยืนยันนั้น สร้างเซสชัน แล้วจึงเปลี่ยนทิศไปยังผู้ให้บริการบน Tableau Server ขั้นที่ 8: ผู้ให้บริการบน Tableau Server จะสร้างคำขอการตรวจสอบสิทธิ์ถึงผู้ให้บริการข้อมูลประจำตัว ขั้นที่ 9: ผู้ให้บริการข้อมูลประจำตัวจะตรวจสอบเซสชันปัจจุบัน ขั้นที่ 10: ผู้ให้บริการบน Tableau Server จะตรวจสอบและสร้างเซสชันของตนเอง แล้วส่งการตอบกลับถึงผู้ใช้ ขั้นตอนที่ 11: ผู้ใช้จะเชื่อมต่อกับ Tableau Server เพื่อให้สิทธิ์ทรัพยากรที่กำหนด](/tableau/next/th-th/guides/enterprise-deployment/th-th/Img/pixel-transparent.png)

## ภาพรวมการกำหนดค่า

ส่วนนี้จะเป็นภาพรวมของกระบวนการเพื่อกำหนดค่าระดับของเว็บ ตรวจสอบการเชื่อมต่อหลังแต่ละขั้นตอน

1. กำหนดค่าพร็อกซีย้อนกลับสองรายการเพื่อให้การเข้าถึง HTTP ไปที่ Tableau Server
2. กำหนดค่าตรรกะการจัดสรรภาระงานกับเซสชันต่อเนื่องบนเซิร์ฟเวอร์พร็อกซีเพื่อเชื่อมต่ออินสแตนซ์ Tableau Server แต่ละรายการที่ใช้กระบวนการของเกตเวย์
3. กำหนดค่าการจัดสรรภาระงานแอปพลิเคชันกับเซสชันต่อเนื่องที่เกตเวย์อินเทอร์เน็ตเพื่อส่งต่อคำขอไปยังเซิร์ฟเวอร์พร็อกซีย้อนกลับ
4. กำหนดค่าการตรวจสอบสิทธิ์กับ IdP ภายนอก คุณสามารถกำหนดค่า SSO หรือ SAML ได้โดยการติดตั้งตัวจัดการการตรวจสอบสิทธิ์บนเซิร์ฟเวอร์พร็อกซีย้อนกลับ โมดูล AuthN จะจัดการแฮนด์เชคการตรวจสอบสิทธิ์ระหว่าง IdP ภายนอกและการปรับใช้ Tableau ของคุณ Tableau จะทำหน้าที่เป็นผู้ให้บริการ IdP และตรวจสอบสิทธิ์ผู้ใช้ด้วย IdP เช่นกัน
5. หากต้องการตรวจสอบสิทธิ์ด้วย Tableau Desktop ในการปรับใช้นี้ ไคลเอ็นต์ของคุณจะต้องใช้ Tableau Desktop 2021.2.1 หรือใหม่กว่า

## ตัวอย่างการกำหนดค่าระดับของเว็บด้วยเกตเวย์อิสระของ Tableau Server

ส่วนที่เหลือของหัวข้อนี้จะแสดงขั้นตอนระดับผู้ใช้ที่อธิบายวิธีการใช้ระดับของเว็บในตัวอย่างสถาปัตยกรรมอ้างอิง AWS ด้วยเกตเวย์อิสระของ Tableau Server สำหรับตัวอย่างการกำหนดค่าโดยใช้ Apache เป็นพร็อกซีย้อนกลับโปรดดู [ภาคผนวก - ระดับเว็บที่มีการใช้งานตัวอย่าง Apache](https://help.tableau.com/v0.0/guides/enterprise-deployment/th-th/edg_part_app-apache.htm)

ตัวอย่างการกำหนดค่าประกอบด้วยองค์ประกอบต่อไปนี้

- ตัวจัดสรรภาระงานแอปพลิเคชัน AWS
- เกตเวย์อิสระของ Tableau Server
- โมดูลการตรวจสอบสิทธิ์ Mellon
- IdP ของ Okta
- การตรวจสอบสิทธิ์ SAML

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

ตัวอย่าง Linux ทั่วทั้งส่วนนี้แสดงคำสั่งสำหรับการกระจายที่คล้ายกับ RHEL โดยระบบได้พัฒนาคำสั่งตรงนี้โดยเฉพาะด้วยการกระจาย Amazon Linux 2 หากเรียกใช้การกระจาย Ubuntu ให้แก้ไขคำสั่งให้สอดคล้องกัน

การปรับใช้ระดับของเว็บในตัวอย่างนี้ปฏิบัติตามกระบวนการตรวจสอบและกำหนดค่าแบบทีละขั้น การกำหนดค่าระดับของเว็บที่สำคัญประกอบด้วยขั้นตอนต่อไปนี้ในการเปิดใช้งาน HTTP ระหว่าง Tableau และอินเทอร์เน็ต ระบบจะเรียกใช้และกำหนดค่าเกตเวย์อิสระให้กับพร็อกซีย้อนกลับ/การจัดสรรภาระงานเบื้องหลังตัวจัดการภาระงานแอปพลิเคชัน AWS:

1. เตรียมสภาพแวดล้อม
2. ติดตั้งเกตเวย์อิสระ
3. กำหนดค่าเซิร์ฟเวอร์เกตเวย์อิสระ
4. กำหนดค่าตัวจัดสรรภาระงานแอปพลิเคชัน AWS

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

### เตรียมสภาพแวดล้อม

ดำเนินงานต่อไปนี้ให้เสร็จก่อนที่คุณจะปรับใช้เกตเวย์อิสระ

1. การเปลี่ยนแปลงกลุ่มการรักษาความปลอดภัย AWS กำหนดค่ากลุ่มการรักษาความปลอดภัยอิสระเพื่ออนุญาตให้การใช้งานเครือข่ายการดูแลความเรียบร้อยของเกตเวย์อิสระขาเข้า (TCP 21319) จากกลุ่มการรักษาความปลอดภัยส่วนตัว
2. ติดตั้งเวอร์ชัน 22.1.1 (หรือใหม่กว่า) บนโหนดทั้งสี่ตัวของคลัสเตอร์ Tableau Server ตามที่ระบุใน [ตอนที่ 4: ติดตั้งและกำหนดค่า Tableau Server](https://help.tableau.com/v0.0/guides/enterprise-deployment/th-th/edg_part4.htm)
3. กำหนดค่าอินสแตนซ์ EC2 ของพร็อกซีทั้งสองตัวในกลุ่มความปลอดภัยสาธารณะตามที่ระบุใน[กำหนดค่าคอมพิวเตอร์โฮสต์](https://help.tableau.com/v0.0/guides/enterprise-deployment/th-th/edg_part3.htm#Install)

### ติดตั้งเกตเวย์อิสระ

เกตเวย์อิสระของ Tableau Server ต้องมีใบอนุญาต Advanced Management

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

หากการปรับใช้ของคุณแตกต่างจากสถาปัตยกรรมอ้างอิง โปรดดูเอกสารประกอบหลักของ Tableau Server _การติดตั้ง Tableau Server กับเกตเวย์อิสระ_ ([Linux](https://help.tableau.com/current/server-linux/th-th/server_tsig_new_install.htm))

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

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

1. ดำเนินการอัปเดตเพื่อใช้การแก้ไขล่าสุดกับ Linux OS
    
    sudo yum update
2. หากติดตั้ง Apache ไว้ ให้ลบออก:
    
     sudo yum remove httpd
3. คัดลอกแพ็กเกจการติดตั้งเกตเวย์อิสระเวอร์ชัน 2022.1.1 (หรือใหม่กว่า) จาก [หน้าดาวน์โหลด Tableau](https://www.tableau.com/th-th/support/releases/server) ไปที่คอมพิวเตอร์โฮสต์ที่จะเรียกใช้ Tableau Server
    
    ตัวอย่างเช่น ในคอมพิวเตอร์ที่ใช้ระบบปฏิบัติการซึ่งคล้ายกับ RHEL ของ Linux ให้เรียกใช้
    
    wget https://downloads.tableau.com/esdalt/2022<version>/tableau-server-tsig-<version>.x86\_64.rpm
4. เรียกใช้โปรแกรมการติดตั้ง ตัวอย่างเช่น เรียกใช้สิ่งต่อไปนี้บนระบบปฏิบัติการที่คล้ายกับ RHEL ของ Linux
    
    sudo yum install <tableau-tsig-version>.x86\_64.rpm
5. เปลี่ยนไปที่ไดเรกทอรี`/opt/tableau/tableau_tsig/packages/scripts.<version_code>/` แล้วเรียกใช้สคริปต์ `initialize-tsig` ที่อยู่ในนั้น นอกเหนือจากแฟล็ก `--accepteula` คุณต้องระบุช่วง IP ของเครือข่ายย่อยที่การปรับใช้ Tableau Server กำลังทำงาน ใช้ตัวเลือก `-c` เพื่อกำหนดช่วง IP ตัวอย่างด้านล่างจะแสดงคำสั่งที่กำหนดเครือข่ายย่อยของ AWS เป็นตัวอย่าง:
    
    sudo ./initialize-tsig --accepteula -c "ip 10.0.30.0/24 10.0.31.0/24"
6. หลังจากที่ขั้นตอนการเริ่มต้นเสร็จสิ้นแล้ว ให้เปิดไฟล์ `tsighk-auth.conf` แล้วคัดลอกข้อมูลลับการตรวจสอบสิทธิ์ในไฟล์ คุณจะต้องส่งโค้ดนี้ให้กับอินสแตนซ์ของเกตเวย์อิสระแต่ละรายการ ซึ่งเป็นส่วนหนึ่งของการกำหนดค่า Tableau Server เบื้องหลัง:
    
    sudo less /var/opt/tableau/tableau\_tsig/config/tsighk-auth.conf
7. หลังจากที่คุณดำเนินการตามขั้นตอนก่อนหน้ากับทั้งสองอินสแตนซ์ของเกตเวย์อิสระแล้ว ให้เตรียมไฟล์การกำหนดค่า `tsig.json` ไฟล์การกำหนดค่าจะประกอบด้วยอาร์เรย์ "independentGateways" อาร์เรย์จะมีออบเจ็กต์การกำหนดค่าที่แต่ละออบเจ็กต์จะกำหนดรายละเอียดการเชื่อมต่อสำหรับอินสแตนซ์เกตเวย์อิสระ
    
    คัดลอก JSON ต่อไปนี้แล้วปรับแต่งตามสภาพแวดล้อมการปรับใช้ของคุณ ตัวอย่างในที่นี้จะแสดงไฟล์ที่เป็นตัวอย่างของสถาปัตยกรรมอ้างอิง AWS
    
    ไฟล์ JSON ตัวอย่างด้านล่างนี้จะมีเฉพาะข้อมูลการเชื่อมต่อสำหรับเกตเวย์อิสระเดียวเท่านั้น ในขั้นตอนถัดๆ ไป คุณจะต้องเพิ่มข้อมูลการเชื่อมต่อสำหรับเซิร์ฟเวอร์เกตเวย์อิสระที่สอง
    
    บันทึกไฟล์เป็น `tsig.json` สำหรับกระบวนการที่ตามมา
    
    {
    "independentGateways": \[
     {
     	"id": "ip-10-0-1-169.ec2.internal",
     	"host": "ip-10-0-1-169.ec2.internal",
     	"port": "21319",
     	"protocol" : "http",
     	"authsecret": "13660-27118-29070-25482-9518-22453"
     	}\]
     }
    
    - `"id"` - ชื่อ DNS ส่วนตัวของอินสแตนซ์ AWS EC2 ที่เรียกใช้เกตเวย์อิสระ.
    - `"host"` - เหมือนกับ `"id"`
    - `"port"` - พอร์ตดูแลความเรียบร้อย ค่าเริ่มต้นคือ `"21319"`
    - `"protocol"` - โปรโตคอลสำหรับการใช้งานเครือข่ายของไคลเอ็นต์ ปล่อยเอาไว้เป็น `http` สำหรับการกำหนดค่าเบื้องต้น
    - `"authsecret"` - ข้อมูลลับที่คุณคัดลอกมาจากขั้นตอนก่อนหน้า

### เกตเวย์อิสระ: การเชื่อมต่อโดยตรงเทียบกับการเชื่อมต่อแบบถ่ายทอด

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

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

- กระบวนการถ่ายทอดส่งผลให้เกิดข้ามขั้นจากเกตเวย์อิสระไปที่กระบวนการเกตเวย์ในเบื้องหลังของ Tableau Server การข้ามขั้นนี้จะทำให้ประสิทธิภาพลดลงเมื่อเทียบกับการกำหนดค่าการเชื่อมต่อโดยตรง
- TLS รองรับโหมดการถ่ายทอด การสื่อสารทั้งหมดในโหมดการถ่ายทอดจะจำกัดโปรโตคอลเดียว (HTTP หรือ HTTPS) ดังนั้นจึงสามารถเข้ารหัสและตรวจสอบสิทธิ์ด้วย TLS ได้

**การเชื่อมต่อโดยตรง**: เกตเวย์อิสระสามารถสื่อสารโดยตรงกับกระบวนการที่ทำงานในเบื้องหลังของ Tableau Server ผ่านหลายพอร์ต เราเรียกการสื่อสารนี้ว่าการเชื่อมต่อ_โดยตรง_:

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

หากต้องการเรียกใช้ TLS ระหว่าง Tableau Server และเกตเวย์อิสระ คุณต้องกำหนดค่าด้วยการเชื่อมต่อแบบถ่ายทอด สถานการณ์ตัวอย่างใน EDG ได้รับการกำหนดค่าด้วยเชื่อมต่อแบบถ่ายทอด

1. คัดลอก `tsig.json` ไปยังโหนด 1 ของการปรับใช้ Tableau Server
2. เรียกใช้คำสั่งต่อไปนี้บนโหนด 1 เพื่อเปิดใช้งานเกตเวย์อิสระ
    
    tsm stop
    tsm configuration set -k gateway.tsig.proxy\_tls\_optional -v none
    tsm pending-changes apply
    tsm topology external-services gateway enable -c tsig.json
    tsm start

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

หากคุณกำลังการกำหนดค่าเกตเวย์อิสระเป็นการเชื่อมต่อโดยตรงไปที่ Tableau Server คุณจะต้องเปิดใช้งานการกำหนดค่าเพื่อทริกเกอร์การสื่อสาร หลังจากที่ Tableau Server สื่อสารกับเกตเวย์อิสระแล้ว ระบบจะกำหนดเป้าหมายโปรโตคอลขึ้น จากนั้นคุณจะต้องได้รับ `proxy_targets.csv` จากคอมพิวเตอร์เกตเวย์อิสระและเปิดพอร์ตที่เกี่ยวข้องจากกลุ่มการรักษาความปลอดภัยสาธารณะถึงส่วนตัวใน AWS

1. คัดลอก `tsig.json` ไปยังโหนด 1 ของการปรับใช้ Tableau Server
2. เรียกใช้คำสั่งต่อไปนี้บนโหนด 1 เพื่อเปิดใช้งานเกตเวย์อิสระ
    
    tsm stop
    tsm topology external-services gateway enable -c tsig.json
    tsm start
3. ในคอมพิวเตอร์เกตเวย์อิสระ ให้เรียกใช้คำสั่งต่อไปนี้เพื่อดูพอร์ตที่คลัสเตอร์ของ Tableau Server กำลังใช้งาน:
    
    less /var/opt/tableau/tableau\_tsig/config/httpd/proxy\_targets.csv
4. กำหนดค่ากลุ่มการรักษาความปลอดภัย AWS เพิ่มพอร์ต TCP ที่ระบุใน `proxy_targets.csv` เพื่ออนุญาตการสื่อสารจากกลุ่มการรักษาความปลอดภัยสาธารณะเป็นกลุ่มการรักษาความปลอดภัยส่วนตัว
    
    เราขอแนะนำให้ตั้งการกำหนดค่าพอร์ตขาเข้าให้เป็นอัตโนมัติ เนื่องจากพอร์ตอาจเปลี่ยนแปลงได้หากการปรับใช้ Tableau Server เปลี่ยนไป การเพิ่มโหนดหรือการกำหนดค่ากระบวนการอีกครั้งในการปรับใช้ Tableau Server จะทำให้เกิดการเปลี่ยนแปลงการเข้าถึงพอร์ตที่เกตเวย์อิสระกำหนดไว้

### การตรวจสอบ: การกำหนดค่าโทโพโลยีฐาน

คุณควรเข้าถึงหน้าผู้ดูแลระบบ Tableau Server ได้โดยการเรียกดู `http://<gateway-public-IP-address>`

หากหน้าเข้าสู่ระบบ Tableau Server ไม่โหลดหรือหาก Tableau Server ไม่เริ่มทำงาน ให้ทำตามขั้นตอนการแก้ปัญหาเหล่านี้:

เครือข่าย: 

- ตรวจสอบการเชื่อมต่อระหว่างการปรับใช้ Tableau และอินสแตนซ์เกตเวย์อิสระโดยเรียกใช้คำสั่ง `wget` ต่อไปนี้จากโหนด 1 ของ Tableau Server: wget http://<internal IP address of Independent Gateway>:21319 เช่น
    
     wget http://ip-10-0-1-38:21319
    
    หากการเชื่อมต่อถูกปฏิเสธหรือล้มเหลว ให้ตรวจสอบว่ากลุ่มความปลอดภัยสาธารณะมีการกำหนดค่าเพื่ออนุญาตให้ใช้งานเครือข่ายการดูแลความเรียบร้อยของเกตเวย์อิสระขาเข้า (TCP 21319) จากกลุ่มความปลอดภัยส่วนตัว
    
    หากกลุ่มความปลอดภัยได้รับการกำหนดค่าอย่างถูกต้อง ให้ตรวจสอบว่าคุณระบุที่อยู่ IP หรือช่วง IP ที่ถูกต้องในระหว่างการเริ่มต้นเกตเวย์อิสระ คุณสามารถดูและเปลี่ยนแปลงการกำหนดค่านี้ได้ในไฟล์ `environment.bash` ซึ่งอยู่ที่`/etc/opt/tableau/tableau_tsig/environment.bash` หากคุณเปลี่ยนแปลงไฟล์นี้ ให้เริ่มบริการ tsig-http ใหม่อีกครั้งตามที่อธิบายไว้ด้านล่าง

บนโฮสต์พร็อกซี 1:

1. เขียนทับไฟล์ httpd.conf ด้วยไฟล์ stub ของเกตเวย์อิสระ:
    
    cp /var/opt/tableau/tableau\_tsig/config/httpd.conf.stub /var/opt/tableau/tableau\_tsig/config/httpd.conf
2. รีสตาร์ท tsig-httpd เป็นขั้นตอนการแก้ปัญหาแรก:
    
    sudo su - tableau-tsig
    systemctl --user restart tsig-httpd
    exit

โหนด 1 ของ Tableau

- ดับเบิลคลิกไฟล์ `tsig.json` หากคุณพบข้อผิดพลาด ให้แก้ไขแล้วเรียกใช้คำสั่ง `tsm topology external-services gateway update -c tsig.json`
- หากเรียกใช้การเชื่อมต่อโดยตรง ให้ตรวจสอบพอร์ต TCP ที่ระบุใน `proxy_targets.csv` ว่ากำหนดค่าเป็นพอร์ตขาเข้าขาเข้าจากกลุ่มการรักษาความปลอดภัยสาธารณะถึงส่วนตัว

### กำหนดค่าตัวจัดสรรภาระงานแอปพลิเคชัน AWS

กำหนดค่าตัวจัดสรรภาระงานในฐานะ HTTP Listener ขั้นตอนตรงนี้อธิบายวิธีเพิ่มตัวจัดสรรภาระงานใน AWS

#### ขั้นตอนที่ 1: สร้างกลุ่มเป้าหมาย

กลุ่มเป้าหมายคือการกำหนดค่า AWS ที่กำหนดอินสแตนซ์ EC2 เพื่อเรียกใช้เซิร์ฟเวอร์พร็อกซีของคุณ สิ่งเหล่านี้เป็นเป้าหมายสำหรับการเข้าชมจาก LBS

1. Ec2>กลุ่มเป้าหมาย > สร้างกลุ่มเป้าหมาย
2. ในหน้าสร้าง ให้ทำสิ่งต่อไปนี้
    
    - ป้อนชื่อกลุ่มเป้าหมาย เช่น `TG-internal-HTTP`
    - ประเภทเป้าหมาย: อินสแตนซ์
    - โปรโตคอล: HTTP
    - พอร์ต: 80
    - VPC: เลือก VPC ของคุณ
    - ในส่วนการตรวจสอบประสิทธิภาพการทำงาน > การตั้งค่าการตรวจสอบประสิทธิภาพการทำงานขั้นสูง > โค้ดความสำเร็จ ให้ผนวกรายการโค้ดเพื่ออ่าน เช่น `200,303`
    - คลิกสร้าง
3. เลือกกลุ่มเป้าหมายที่เพิ่งสร้างขึ้น แล้วคลิกแท็บเป้าหมาย 
    
    - คลิกแก้ไข
    - เลือกอินสแตนซ์ EC2 (หรืออินสแตนซ์เดี่ยวหากคุณกำลังกำหนดค่าทีละรายการ) ที่กำลังเรียกใช้แอปพลิเคชันพร็อกซี จากนั้นคลิกเพิ่มในการลงทะเบียน
    - คลิกบันทึก

#### ขั้นตอนที่ 2: เรียกใช้ตัวช่วยตัวจัดสรรภาระงาน

1. EC2> ตัวจัดสรรภาระงาน > สร้างตัวจัดสรรภาระงาน
2. ในหน้า "เลือกประเภทตัวจัดสรรภาระงาน" ให้สร้าง Application Load Balancer

**หมายเหตุ**: UI ที่แสดงเพื่อกำหนดค่าตัวจัดสรรภาระงานไม่สอดคล้องกันในศูนย์ข้อมูล AWS ขั้นตอนด้านล่าง "การกำหนดค่าตัวช่วย" จะจับคู่กับตัวช่วยการกำหนดค่า AWS ที่เริ่มต้นด้วย**ขั้นตอนที่ 1 กำหนดค่าตัวจัดสรรภาระงาน**   
  
หากศูนย์ข้อมูลของคุณแสดงการกำหนดค่าทั้งหมดในหน้าเดียวที่มีปุ่ม**สร้างตัวจัดสรรภาระงาน**ที่ด้านล่างของหน้า ให้ทำตามขั้นตอน "การกำหนดค่าหน้าเดียว" ด้านล่าง

1. กำหนดค่าหน้าการจัดสรรภาระงาน
    
    - ระบุชื่อ
    - สคีมา: internet-facing (ค่าเริ่มต้น)
    - ประเภทที่อยู่ IP: ipv4 (ค่าเริ่มต้น)
    - Listener (Listener และการกำหนดเส้นทาง):
        1. ปล่อยให้ HTTP Listener เป็นค่าเริ่มต้น
        2. คลิกเพิ่ม Listenerและเพิ่ม`HTTPS:443`
    
    - VPC: เลือก VPC ที่คุณได้ติดตั้งทุกอย่างไว้
    - โซนความพร้อมใช้งาน:
        - เลือก **a** และ **b** สำหรับภูมิภาคศูนย์ข้อมูลของคุณ
        - ในตัวเลือกแบบเลื่อนลงแต่ละรายการที่เกี่ยวข้อง ให้เลือกซับเน็ตสาธารณะ (ที่เซิร์ฟเวอร์พร็อกซีของคุณอยู่)
    - คลิก: กำหนดการตั้งค่าความปลอดภัย
2. หน้ากำหนดการตั้งค่าความปลอดภัย
    
    - อัปโหลดใบรับรอง SSL สาธารณะของคุณ
    - คลิกถัดไป: กำหนดค่ากลุ่มความปลอดภัย
3. หน้ากำหนดค่ากลุ่มความปลอดภัย
    
    - เลือกกลุ่มการรักษาความปลอดภัยแบบสาธารณะ หากเลือกกลุ่มการรักษาความปลอดภัยที่เป็นค่าเริ่มต้นไว้ ให้ล้างการเลือกดังกล่าว
    - คลิกถัดไป: กำหนดค่าการกำหนดเส้นทาง
4. หน้ากำหนดค่าการกำหนดเส้นทาง
    
    - กลุ่มเป้าหมาย: กลุ่มเป้าหมายที่มีอยู่
    - ชื่อ: เลือกกลุ่มเป้าหมายที่คุณสร้างไว้ก่อนหน้านี้
    - คลิกถัดไป: ลงทะเบียนเป้าหมาย
5. หน้าลงทะเบียนเป้าหมาย
    
    - ควรแสดงอินสแตนซ์เซิร์ฟเวอร์พร็อกซีสองอินสแตนซ์ที่คุณกำหนดค่าไว้ก่อนหน้านี้
    - คลิกถัดไป: ตรวจสอบ
6. หน้าตรวจสอบ
    
    คลิกสร้าง

การกำหนดค่าพื้นฐาน

- ระบุชื่อ
- สคีมา: internet-facing (ค่าเริ่มต้น)
- ประเภทที่อยู่ IP: ipv4 (ค่าเริ่มต้น)

การแมปเครือข่าย

- VPC: เลือก VPC ที่คุณได้ติดตั้งทุกอย่างไว้
- การแมป:
    - เลือกโซนความพร้อมใช้งาน **a** และ **b** (หรือเทียบเท่า) สำหรับภูมิภาคศูนย์ข้อมูลของคุณ
    - ในตัวเลือกแบบเลื่อนลงแต่ละรายการที่เกี่ยวข้อง ให้เลือกซับเน็ตสาธารณะ (ที่เซิร์ฟเวอร์พร็อกซีของคุณอยู่)

กลุ่มความปลอดภัย

- เลือกกลุ่มการรักษาความปลอดภัยแบบสาธารณะ หากเลือกกลุ่มการรักษาความปลอดภัยที่เป็นค่าเริ่มต้นไว้ ให้ล้างการเลือกดังกล่าว

Listener และการกำหนดเส้นทาง

- ปล่อยให้ HTTP Listener เป็นค่าเริ่มต้น สำหรับ Default action (การดำเนินการที่เป็นค่าเริ่มต้น) ให้ระบุกลุ่มเป้าหมายที่คุณเคยตั้งค่าไว้ก่อนหน้านี้
- คลิกเพิ่ม Listener และเพิ่ม`HTTPS:443` สำหรับ Default action (การดำเนินการที่เป็นค่าเริ่มต้น) ให้ระบุกลุ่มเป้าหมายที่คุณเคยตั้งค่าไว้ก่อนหน้านี้

การตั้งค่า Listener ที่ปลอดภัย

- อัปโหลดใบรับรอง SSL สาธารณะของคุณ

คลิกสร้างตัวจัดสรรภาระงาน

#### ขั้นตอนที่ 3: เปิดใช้งานความสามารถในการดึงดูด

1. หลังจากสร้างตัวจัดสรรภาระงานแล้ว คุณต้องเปิดใช้งานความสามารถในการดึงดูดกับกลุ่มเป้าหมาย
    
    - เปิดหน้ากลุ่มเป้าหมาย AWS (EC2\> การจัดสรรภาระงาน\> กลุ่มเป้าหมาย) เลือกอินสแตนซ์กลุ่มเป้าหมายที่เพิ่งตั้งค่า ในเมนูการดำเนินการ ให้เลือกแก้ไขแอตทริบิวต์
    - ในหน้าแก้ไขแอตทริบิวต์ ให้เลือกความสามารถในการดึงดูด ระบุระยะเวลา `1 day` แล้วบันทึกการเปลี่ยนแปลง
2. ในตัวจัดสรรภาระงาน ให้เปิดใช้ความสามารถในการดึงดูดบน HTTP Listener เลือกตัวจัดสรรภาระงานที่คุณเพิ่งกำหนดค่าไว้ แล้วคลิกแท็บ Listener
    
    - สำหรับ HTTP:80 ให้คลิกดู/แก้ไขกฎ ในหน้ากฎที่เป็นผลลัพธ์ ให้คลิกไอคอนแก้ไข (เคยอยู่ที่ด้านบนของหน้า แล้วกลับมาอยู่ข้างกฎอีกครั้ง) เพื่อแก้ไขกฎ ลบกฎ THEN ที่มีอยู่และแทนที่กฎดังกล่าวโดยการคลิกเพิ่มการดำเนินการ > ส่งต่อไปยัง... ในการกำหนดค่า THEN ให้เป็นผลลัพธ์ ให้ระบุกลุ่มเป้าหมายเดียวกันกับที่คุณสร้างขึ้น เปิดใช้ความสามารถในการดึงดูดและกำหนดระยะเวลาเป็น 1 วันในส่วนความสามารถในการดึงดูดระดับกลุ่ม บันทึกการตั้งค่าแล้วคลิกอัปเดต

#### ขั้นตอนที่ 4: ตั้งค่าการหมดเวลาที่ไม่มีการใช้งานบนตัวกระจายโหลด

ในตัวกระจายโหลด ให้อัปเดตการหมดเวลาที่ไม่มีการใช้งานเป็น 400 วินาที

เลือกตัวจัดสรรภาระงานที่กำหนดค่าไว้สำหรับการปรับใช้ แล้วคลิกการดำเนินการ > แก้ไขแอตทริบิวต์ กำหนดการหมดเวลาที่ไม่มีการใช้งานเป็น `400` วินาที จากนั้นคลิกบันทึก

#### ขั้นตอนที่ 5: ตรวจสอบการเชื่อมต่อ LBS

เปิดหน้าตัวจัดสรรภาระงาน AWS (EC2\> ตัวจัดสรรภาระงาน) เลือกอินสแตนซ์ตัวจัดสรรภาระงานที่เพิ่งตั้งค่า

ภายใต้คำอธิบาย ให้คัดลอกชื่อ DNS และวางลงในเบราว์เซอร์เพื่อเข้าถึงหน้าเข้าสู่ระบบ Tableau Server

หากคุณพบกับข้อผิดพลาดรหัส 500 คุณอาจต้องรีสตาร์ทเซิร์ฟเวอร์พร็อกซี

### อัปเดต DNS ด้วย URL สาธารณะของ Tableau

ใช้ชื่อโซน DNS ของโดเมนจากคำอธิบายตัวจัดสรรภาระงาน AWS เพื่อสร้างค่า CNAME ใน DNS ระบบควรส่งการเข้าชมไปยัง URL (tableau.example.com) ไปที่ชื่อ DNS สาธารณะของ AWS

### ตรวจสอบการเชื่อมต่อ

หลังจากที่อัปเดต DNS เสร็จสิ้น คุณควรไปที่หน้าเข้าสู่ระบบ Tableau Server ได้โดยการป้อน URL สาธารณะ เช่น `https://tableau.example.com`

## ตัวอย่างการกำหนดค่าการตรวจสอบสิทธิ์: SAML ที่มี IdP ภายนอก

ตัวอย่างต่อไปนี้อธิบายวิธีตั้งค่าและกำหนดค่า SAML ด้วย IdP ของ Okta และโมดูลการตรวจสอบสิทธิ์ Mellon สำหรับการปรับใช้ Tableau ที่ทำงานในสถาปัตยกรรมอ้างอิง AWS

ตัวอย่างนี้จะหยิบยกขึ้นมาจากส่วนก่อนหน้านี้ และจะสมมติว่าคุณกำลังกำหนดค่าเกตเวย์อิสระครั้งละหนึ่งเกตเวย์

ตัวอย่างจะอธิบายวิธีการกำหนดค่า Tableau Server และเกตเวย์อิสระผ่าน HTTP Okta จะส่งคำขอไปยังตัวจัดสรรภาระงาน AWS ผ่าน HTTPS แต่การเข้าชมภายในทั้งหมดจะเคลื่อนผ่าน HTTP เมื่อคุณกำหนดค่าสำหรับสถานการณ์นี้ อย่าลืมคำนึงถึงโปรโตคอล HTTP กับ HTTPS เมื่อตั้งค่าสตริง URL

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

### สร้างบัญชีผู้ดูแลระบบ Tableau

ข้อผิดพลาดทั่วไปเมื่อกำหนดค่า SAML คือการลืมสร้างบัญชีผู้ดูแลระบบบน Tableau Server ก่อนเปิดใช้ SSO

ขั้นตอนแรกคือการสร้างบัญชีบน Tableau Server โดยมีบทบาทผู้ดูแลเซิร์ฟเวอร์ ตัวอย่างเช่น สถานการณ์ของ Okta ชื่อผู้ใช้ต้องอยู่ในรูปแบบที่อยู่อีเมลที่ถูกต้อง เช่น user@example.com คุณต้องตั้งรหัสผ่านสำหรับผู้ใช้รายนี้ แต่ไม่จำเป็นต้องใช้รหัสผ่านหลังจากกำหนดค่า SAML แล้ว

### กำหนดค่าแอปพลิเคชันตรวจสอบสิทธิ์ล่วงหน้า Okta

สถานการณ์ตั้งแต่ต้นทางถึงปลายทางที่อธิบายไว้ในส่วนนี้ต้องใช้แอปพลิเคชัน Okta สองแอปดังนี้:

- แอปพลิเคชันตรวจสอบสิทธิ์ล่วงหน้า Okta
- แอปพลิเคชัน Okta Tableau Server

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

ขั้นตอนนี้อธิบายวิธีสร้างและกำหนดค่าแอปพลิเคชันตรวจสอบสิทธิ์ล่วงหน้า Okta ต่อมาในหัวข้อนี้ คุณจะสร้างแอปพลิเคชัน Okta Tableau Server สำหรับบัญชีทดสอบฟรีของ Okta ที่มีผู้ใช้จำกัด โปรดดูที่[หน้าเว็บ Okta Developer](https://developer.okta.com/signup/)

สร้างการผสานรวมแอป SAML สำหรับผู้ให้บริการตรวจสอบสิทธิ์ล่วงหน้า Mellon

1. เปิดแดชบอร์ดดูแลระบบ Okta > แอปพลิเคชัน > สร้างการผสานรวมแอป
2. บนหน้าสร้างการผสานรวมแอป ให้เลือก SAML 2.0 จากนั้นคลิกถัดไป
3. บนแท็บการตั้งค่าทั่วไป ให้ป้อนชื่อแอป เช่น `Tableau Pre-Auth` จากนั้นคลิกถัดไป
4. บนแท็บกำหนดค่า SAML ดังนี้:
    
    - URL การลงชื่อเพียงครั้งเดียว (SSO) องค์ประกอบสุดท้ายของเส้นทางใน URL การลงชื่อเพียงครั้งเดียวเรียกว่า `MellonEndpointPath` ในไฟล์การกำหนดค่า `mellon.conf` ที่ตามมาภายหลังในกระบวนการนี้ คุณสามารถระบุปลายทางที่คุณต้องการได้ ในตัวอย่างนี้ `sso` คือปลายทาง จำเป็นต้องมีองค์ประกอบสุดท้าย `postResponse`: `https://tableau.example.com/sso/postResponse`.
    - ล้างช่องทำเครื่องหมายดังนี้: ใช้สำหรับ URL ผู้รับและ URL ปลายทาง
    - URL ผู้รับ: เหมือนกับ URL SSO แต่มี HTTP ตัวอย่างเช่น `http://tableau.example.com/sso/postResponse`
    - URL ปลายทาง: เหมือนกับ URL SSO แต่มี HTTP ตัวอย่างเช่น `http://tableau.example.com/sso/postResponse`
    - URI กลุ่มเป้าหมาย (ID เอนทิตี SP) ตัวอย่างเช่น `https://tableau.example.com`
    - รูปแบบ ID ชื่อ: `EmailAddress`
    - ชื่อผู้ใช้แอปพลิเคชัน: `Email`
    - คำสั่งแอตทริบิวต์: ชื่อ = `mail` รูปแบบชื่อ = `Unspecified` ค่า = `user.email`
    
    คลิกถัดไป
5. บนแท็บ ข้อเสนอแนะ ให้เลือกดังนี้:
    
    - ฉันเป็นลูกค้าของ Okta ที่เพิ่มแอปภายใน
    - นี่คือแอปภายในที่เราสร้างขึ้น
    - คลิกเสร็จสิ้น
6. สร้างไฟล์ข้อมูลเมตา IdP การตรวจสอบสิทธิ์ล่วงหน้าดังนี้:
    
    - ใน Okta: แอปพลิเคชัน > แอปพลิเคชัน > แอปพลิเคชันใหม่ของคุณ (เช่น `Tableau Pre-Auth`) > การลงชื่อเข้าใช้
    - ถัดจากใบรับรองการลงชื่อ SAML ให้คลิกดูคำแนะนำการตั้งค่า SAML
    - บนหน้าวิธีกำหนดค่า SAML 2.0 สำหรับแอปพลิเคชัน <pre-auth> ให้เลื่อนลงไปที่ส่วน ไม่บังคับ ระบุข้อมูลเมตา IDP ต่อไปนี้ให้กับผู้ให้บริการ SP ของคุณ
    - คัดลอกเนื้อหาของฟิลด์ XML และบันทึกลงในไฟล์ชื่อ `pre-auth_idp_metadata.xml`
7. (ไม่บังคับ) กำหนดค่าการตรวจสอบสิทธิ์หลายปัจจัยดังนี้:
    
    - ใน Okta: แอปพลิเคชัน > แอปพลิเคชัน > แอปพลิเคชันใหม่ของคุณ (เช่น `Tableau Pre-Auth`) > การลงชื่อเข้าใช้
    - ภายใต้นโยบายการลงชื่อเข้าใช้ ให้คลิกเพิ่มกฎ
    - ในกฎการลงชื่อเข้าใช้แอป ให้ระบุชื่อและตัวเลือก MFA ต่างๆ หากต้องการทดสอบฟังก์ชันการทำงาน คุณสามารถกำหนดตัวเลือกทั้งหมดเป็นค่าเริ่มต้น อย่างไรก็ตาม ในส่วนการดำเนินการ คุณต้องเลือกข้อความแจ้งสำหรับปัจจัย จากนั้นระบุความถี่ที่ผู้ใช้ต้องเข้าสู่ระบบ และคลิกบันทึก

### สร้างและกำหนดผู้ใช้ Okta

1. ใน Okta สร้างผู้ใช้ด้วยชื่อผู้ใช้เดียวกับที่คุณสร้างใน Tableau (user@example.com): ไดเรกทอรี > บุคคล > เพิ่มบุคคล
2. หลังจากที่สร้างผู้ใช้แล้ว ให้กำหนดแอป Okta ใหม่ให้กับบุคคลนั้นๆ ดังนี้: คลิกชื่อผู้ใช้ จากนั้นกำหนดแอปพลิเคชันในกำหนดแอปพลิเคชัน

### ติดตั้ง Mellon สำหรับการตรวจสอบสิทธิ์ล่วงหน้า

ตัวอย่างนี้จะใช้ mod\_auth\_mellon ซึ่งเป็นโมดูลโอเพนซอร์ซยอดนิยม แพ็กเกจการแจกจ่าย Linux บางส่วนเป็นเวอร์ชัน mod\_auth\_mellon ที่ล้าสมัยจากที่เก็บที่เก่ากว่า เวอร์ชันที่ล้าสมัยเหล่านั้นอาจมีช่องโหว่ด้านความปลอดภัยที่ไม่รู้จักหรือมีปัญหาการทำงาน หากคุณเลือกใช้ mod\_auth\_mellon โปรดตรวจดูว่าคุณกำลังใช้เวอร์ชันปัจจุบัน

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

1. บนอินสแตนซ์ EC2 ที่กำลังทำงานซึ่งเรียกใช้เกตเวย์อิสระ ให้ติดตั้งโมดูลการตรวจสอบสิทธิ Mellon เวอร์ชันปัจจุบัน
2. สร้างไดเรกทอรี `/etc/mellon`:
    
    sudo mkdir /etc/mellon

### กำหนดค่า Mellon เป็นโมดูลการตรวจสอบสิทธิ์ล่วงหน้า

เรียกใช้โกระบวนการนี้ในอินสแตนซ์แรกของเกตเวย์อิสระ

คุณต้องมีสำเนาของไฟล์ `pre-auth_idp_metadata.xml` ที่สร้างไว้จากการกำหนดค่า Okta

1. เปลี่ยนไดเรกทอรี
    
    cd /etc/mellon
2. สร้างเมตาดาต้าของผู้ให้บริการ เรียกใช้สคริปต์ `mellon_create_metadata.sh` คุณต้องรวม ID เอนทิตีและ URL การส่งคืนสำหรับองค์กรของคุณในคำสั่ง
    
    URL การส่งคืนจะเรียกว่า _URL สำหรับการลงชื่อเพียงครั้งเดียว_ใน Okta องค์ประกอบสุดท้ายของเส้นทางใน URL การส่งคืนจะเรียกว่า `MellonEndpointPath` ในไฟล์การกำหนดค่า `mellon.conf` ที่จะตามมาภายหลังในกระบวนการนี้ ในตัวอย่างนี้ เราระบุ `sso` เป็นเส้นทางปลายทาง
    
    ตัวอย่าง:
    
    sudo /usr/libexec/mod\_auth\_mellon/mellon\_create\_metadata.sh https://tableau.example.com "https://tableau.example.com/sso"
    
    สคริปต์ส่งคืนใบรับรอง คีย์ และไฟล์เมตาดาต้าของผู้ให้บริการ
3. เปลี่ยนชื่อไฟล์ของผู้ให้บริการในไดเรกทอรี `mellon` เพื่อให้อ่านง่ายขึ้น เราจะดูไฟล์เหล่านี้ตามชื่อต่อไปนี้ในเอกสารประกอบ
    
    sudo mv \*.key mellon.key  
    sudo mv \*.cert mellon.cert  
    sudo mv \*.xml sp\_metadata.xml
4. คัดลอกไฟล์ `pre-auth_idp_metadata.xml` ไปยังไดเรกทอรีเดียวกัน
5. เปลี่ยนเจ้าของและสิทธิ์บนไฟล์ทั้งหมดในไดเรกทอรี `/etc/mellon` ดังนี้
    
    sudo chown tableau-tsig mellon.key
    sudo chown tableau-tsig mellon.cert
    sudo chown tableau-tsig sp\_metadata.xml
    sudo chown tableau-tsig pre-auth\_idp\_metadata.xml 
    sudo chmod +r \* mellon.key
    sudo chmod +r \* mellon.cert
    sudo chmod +r \* sp\_metadata.xml
    sudo chmod +r \* pre-auth\_idp\_metadata.xml
6. สร้างไดเรกทอรี `/etc/mellon/conf.d`:
    
    sudo mkdir /etc/mellon/conf.d
7. สร้างไฟล์ `global.conf` ในไดเรกทอรี `/etc/mellon/conf.d`
    
    คัดลอกเนื้อหาที่แสดงด้านล่าง แต่อัปเดต `MellonCookieDomain` ด้วยชื่อโดเมนรูทของคุณ ตัวอย่างเช่น หากชื่อโดเมนของ Tableau คือ `tableau.example.com` ให้ป้อน `example.com` เป็นโดเมนรูท
    
    <Location "/">
    AuthType Mellon
    MellonEnable auth
    Require valid-user
    MellonCookieDomain <root domain>
    MellonSPPrivateKeyFile /etc/mellon/mellon.key
    MellonSPCertFile /etc/mellon/mellon.cert
    MellonSPMetadataFile /etc/mellon/sp\_metadata.xml
    MellonIdPMetadataFile /etc/mellon/pre-auth\_idp\_metadata.xml
    MellonEndpointPath /sso
    </Location>
    
    <Location "/tsighk">
    MellonEnable Off
    </Location>
8. สร้างไฟล์ `mellonmod.conf` ในไดเรกทอรี `/etc/mellon/conf.d`
    
    ไฟล์นี้จะมีคำสั่งเดียวที่ระบุตำแหน่งของไฟล์ `mod_auth_mellon.so` ตำแหน่งในตัวอย่างนี้จะเป็นตำแหน่งตามค่าเริ่มต้นของไฟล์ ตรวจดูว่าไฟล์อยู่ในตำแหน่งนี้ หรือเปลี่ยนเส้นทางในคำสั่งนี้ให้ตรงกับตำแหน่งจริงของ `mod_auth_mellon.so`
    
    LoadModule auth\_mellon\_module /usr/lib64/httpd/modules/mod\_auth\_mellon.so

### สร้างแอปพลิเคชัน Tableau Server ใน Okta

1. ในแดชบอร์ด Okta: แอปพลิเคชัน \> แอปพลิเคชัน \> ดูแคตตาล็อกแอป
2. ในดูแคตตาล็อกการผสานรวมแอป ให้ค้นหา `Tableau` เลือกชิ้นส่วน Tableau Server แล้วคลิกเพิ่ม
3. ในส่วนเพิ่ม Tableau Server > การตั้งค่าทั่วไป ให้ป้อนป้ายกำกับแล้วคลิกถัดไป
4. ในตัวเลือกการลงชื่อ ให้เลือก SAML 2.0 แล้วเลื่อนลงไปที่การตั้งค่าการลงชื่อขั้นสูง ดังนี้
    - ID เอนทิตี SAML: ป้อน URL สาธารณะ เช่น https://tableau.example.com
    - รูปแบบชื่อผู้ใช้แอปพลิเคชัน: อีเมล
5. คลิกลิงก์ข้อมูลเมตาของผู้ให้บริการข้อมูลระบุตัวตนเพื่อเปิดเบราว์เซอร์ คัดลอกลิงก์เบราว์เซอร์ คุณจะใช้ลิงก์นี้เมื่อกำหนดค่า Tableau ในขั้นตอนถัดไป
6. คลิกเสร็จสิ้น
7. มอบหมายแอป Okta ใหม่สำหรับ Tableau Server ให้กับผู้ใช้ (user@example.com): คลิกชื่อผู้ใช้จากนั้นมอบหมายแอปพลิเคชันในมอบหมายแอปพลิเคชัน

### กำหนดค่าโมดูลการตรวจสอบสิทธิ์บน Tableau Server

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

tsm configuration set -k gateway.tsig.authn\_module\_block -v "/etc/mellon/conf.d/mellonmod.conf" --force-keys
tsm configuration set -k gateway.tsig.authn\_global\_block -v "/etc/mellon/conf.d/global.conf" --force-keys

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

### เปิดใช้งาน SAML บน Tableau Server สำหรับ IdP

เรียกใช้โพรซีเยอร์นี้บน Tableau Server โหนด 1

1. ดาวน์โหลดข้อมูลเมตาของแอปพลิเคชัน Tableau Server จาก Okta ใช้ลิงก์ที่คุณบันทึกไว้จากขั้นตอนก่อนหน้านี้:
    
    wget https://dev-66144217.okta.com/app/exk1egxgt1fhjkSeS5d7/sso/saml/metadata -O idp\_metadata.xml
2. คัดลอกใบรับรอง TLS และไฟล์สำคัญที่เกี่ยวข้องไปยัง Tableau Server ไฟล์สำคัญต้องเป็นคีย์ RSA หากต้องการหากต้องการข้อมูลเพิ่มเติมเกี่ยวกับใบรับรองและข้อกำหนดของ IdP โปรดดู _ข้อกำหนดของ SAML Requirement_ ([Linux](https://help.tableau.com/current/server-linux/th-th/saml_requ.htm))
    
    หากต้องการทำให้การปรับใช้และการจัดการใบรับรองง่ายขึ้น พร้อมทั้งเป็นแนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย เราขอแนะนำให้ใช้ใบรับรองที่สร้างโดยผู้ออกใบรับรอง (CA) บุคคลที่สามรายใหญ่ที่เชื่อถือได้ หรือคุณอาจสร้างใบรับรองที่ลงนามด้วยตนเองหรือใช้ใบรับรองจาก PKI สำหรับ TLS ก็ได้เช่นกัน
    
    หากไม่มีใบรับรอง TLS คุณสามารถสร้างใบรับรองที่ลงนามเองได้โดยใช้โพรซีเยอร์ที่ฝังไว้ด้านล่าง
    
    สร้างใบรับรองที่ลงนามเอง
    
    เรียกใช้โพรซีเยอร์นี้บน Tableau Server โหนด 1
    
    1. สร้างคีย์ผู้ออกใบรับรอง (CA) ระดับรูทที่ลงนาม
        
        openssl genrsa -out rootCAKey-saml.pem 2048
    2. สร้างใบรับรอง CA ระดับรูท
        
        openssl req -x509 -sha256 -new -nodes -key rootCAKey-saml.pem -days 3650 -out rootCACert-saml.pem
        
        ระบบจะแจ้งให้คุณป้อนค่าสำหรับฟิลด์ใบรับรอง ตัวอย่าง:
        
        Country Name (2 letter code) \[XX\]:US
        State or Province Name (full name) \[\]:Washington
        Locality Name (eg, city) \[Default City\]:Seattle
        Organization Name (eg, company) \[Default Company Ltd\]:Tableau
        Organizational Unit Name (eg, section) \[\]:Operations
        Common Name (eg, your name or your server's hostname) \[\]:tableau.example.com
        Email Address \[\]:example@tableau.com
    3. สร้างใบรับรองและคีย์ที่เกี่ยวข้อง (`server-saml.csr` และ `server-saml.key` ในตัวอย่างด้านล่าง) ชื่อเรื่องของใบรับรองต้องตรงกับชื่อโฮสต์สาธารณะของโฮสต์ Tableau ระบบกำหนดชื่อเรื่องด้วยตัวเลือก `-subj` ที่มีรูปแบบ `"/CN=<host-name>"` เช่น
        
        openssl req -new -nodes -text -out server-saml.csr -keyout server-saml.key -subj "/CN=tableau.example.com"
    4. ลงนามใบรับรองใหม่ด้วยใบรับรอง CA ที่สร้างไว้ด้านบน คำสั่งต่อไปนี้ยังส่งออกใบรับรองในรูปแบบ `crt` อีกด้วย
        
        openssl x509 -req -in server-saml.csr -days 3650 -CA rootCACert-saml.pem -CAkey rootCAKey-saml.pem -CAcreateserial -out server-saml.crt
    5. แปลงไฟล์สำคัญเป็น RSA Tableau ต้องใช้ไฟล์สำคัญ RSA สำหรับ SAML หากต้องการแปลงคีย์ ให้เรียกใช้คำสั่งต่อไปนี้:
        
        openssl rsa -in server-saml.key -out server-saml-rsa.key
3. กำหนดค่า SAML เรียกใช้คำสั่งต่อไปนี้ โดยระบุ ID เอนทิตีและ URL การส่งคืน และเส้นทางไปยังไฟล์ข้อมูลเมตา ไฟล์ใบรับรอง และไฟล์สำคัญ:
    
    tsm authentication saml configure --idp-entity-id "https://tableau.example.com" --idp-return-url "https://tableau.example.com" --idp-metadata idp\_metadata.xml --cert-file "server-saml.crt" --key-file "server-saml-rsa.key"
    
    tsm authentication saml enable
4. หากองค์กรของคุณใช้ Tableau Desktop 2021.4 หรือใหม่กว่า คุณจะต้องเรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้งานการตรวจสอบสิทธิ์ผ่านเซิร์ฟเวอร์พร็อกซีแบบย้อนกลับ
    
    เวอร์ชันของ Tableau Desktop 2021.2.1 - 2021.3 จะทำงานโดยไม่ต้องมีการเรียกใช้คำสั่งนี้ โดยที่โมดูลการตรวจสอบสิทธิ์ล่วงหน้าของคุณ (เช่น Mellon) จะได้รับการกำหนดค่าให้อนุญาตการเก็บรักษาคุกกี้ของโดเมนระดับบนสุดเอาไว้
    
    tsm configuration set -k features.ExternalBrowserOAuth -v false
5. ปรับใช้การเปลี่ยนแปลงการกำหนดค่า:
    
    tsm pending-changes apply

#### การรีสตาร์ทบริการ tsig-httpd

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

sudo su - tableau-tsig
systemctl --user restart tsig-httpd
exit

### ตรวจสอบฟังก์ชันการทำงานของ SAML

หากต้องการตรวจสอบฟังก์ชันการทำงานของ SAML ตั้งแต่ต้นทางถึงปลายทาง ให้เข้าสู่ระบบ Tableau Server ผ่าน URL สาธารณะ (เช่น https://tableau.example.com) ด้วยบัญชีผู้ดูแลระบบ Tableau ที่สร้างไว้ตอนเริ่มต้นกระบวนการนี้

หาก TSM ไม่เริ่มทำงาน ("ข้อผิดพลาดของเกตเวย์") หรือหากคุณได้รับข้อผิดพลาดของเบราว์เซอร์เมื่อคุณพยายามเชื่อมต่อ โปรดดูที่[การแก้ปัญหาเกตเวย์อิสระของ Tableau Server](https://help.tableau.com/v0.0/guides/enterprise-deployment/th-th/edg_part7.htm#Troubles)

## กำหนดค่าโมดูลการตรวจสิบสิทธิบนอินสแตนซ์ที่สองของเกตเวย์อิสระ

หลังจากที่กำหนดค่าอินสแตนซ์แรกของเกตเวย์อิสระเรียบร้อยแล้ว ให้ปรับใช้อินสแตนซ์ที่ 2 ตัวอย่างในที่นี้คือกระบวนการขั้นสุดท้ายของการติดตั้งกรณีใช้งาน AWS/Mellon/Okta ตามที่อธิบายในหัวข้อนี้ กระบวนการจะสมมติว่าคุณได้ติดตั้งเกตเวย์อิสระบนอินสแตนซ์ที่สองตามที่อธิบายในหัวข้อก่อนหน้านี้แล้ว ([ติดตั้งเกตเวย์อิสระ](#Install))

กระบวนการสำหรับการปรับใช้เกตเวย์อิสระที่ 2 ต้องทำตามขั้นตอนต่อไปนี้

1. บนอินสแตนซ์ที่สองของเกตเวย์อิสระ: ติดตั้งโมดูลการตรวจสอบสิทธิของ Mellon
    
    อย่ากำหนดค่าโมดูลการตรวจสอบสิทธิของ Mellon ตามที่อธิบายไว้ก่อนหน้าในหัวข้อนี้ แต่ให้คุณต้องลอกแบบการกำหนดค่าตามที่อธิบายไว้ในขั้นตอนต่อมาแทน
2. บนอินสแตนซ์ (แรก) ที่กำหนดค่าของเกตเวย์อิสระ:
    
    ทำสำเนา tar ของการกำหนดค่า Mellon ที่มีอยู่ ข้อมูลสำรอง tar จะเก็บรักษาลำดับชั้นและสิทธิ์ของไดเรกทอรีทั้งหมด เรียกใช้คำสั่งต่อไปนี้:
    
    cd /etc
    
    sudo tar -cvf mellon.tar mellon
    
    คัดลอก `mellon.tar` ไปยังอินสแตนซ์ที่สองของเกตเวย์อิสระ
3. บนอินสแตนซ์ที่สองของเกตเวย์อิสระ:
    
    แยกข้อมูล ("unzip") ไฟล์ tar ไปยังอินสแตนซ์ที่สองในไดเรกทอรี `/etc` เรียกใช้คำสั่งต่อไปนี้:
    
    cd /etc
    
    sudo tar -xvf mellon.tar
4. บนโหนด 1 ของการปรับใช้ Tableau Server: อัปเดตไฟล์การเชื่อมต่อ (`tsig.json`) ด้วยข้อมูลการเชื่อมต่อจากเกตเวย์อิสระที่ 2 คุณจะต้องเรียกคีย์การตรวจสอบสิทธิ์ตามที่อธิบายในหัวข้อก่อนหน้า ([ติดตั้งเกตเวย์อิสระ](#Install))
    
    ตัวอย่างไฟล์การเชื่อมต่อ (`tsig.json`) จะปรากฏที่นี่
    
    {
    "independentGateways": \[
     {
       "id": "ip-10-0-1-169.ec2.internal",
       "host": "ip-10-0-1-169.ec2.internal",
       "port": "21319",
       "protocol" : "http",
       "authsecret": "13660-27118-29070-25482-9518-22453"
     },
     {
       "id": "ip-10-0-2-230.ec2.internal",
       "host": "ip-10-0-2-230.ec2.internal",
       "port": "21319",
       "protocol" : "http",
       "authsecret": "9055-27834-16487-27455-30409-7292"
     }\]
     }
5. บนโหนด 1 ของการปรับใช้ Tableau Server: เรียกใช้คำสั่งต่อไปนี้เพื่ออัปเดตการกำหนดค่า
    
    tsm stop
    
    tsm topology external-services gateway update -c tsig.json
    
    tsm start
6. บนอินสแตนซ์ทั้ง 2 รายการของเกตเวย์อิสระ: เมื่อ Tableau Server เริ่มต้นทำงาน ให้รีสตาร์ทกระบวนการ `tsig-httpd`
    
    sudo su - tableau-tsig
    
    systemctl --user restart tsig-httpd
    
    exit
7. ใน AWS EC2>กลุ่มเป้าหมาย: อัปเดตกลุ่มเป้าหมายเพื่อรวมอินสแตนซ์ EC2 ที่ใช้อินสแตนซ์ของเกตเวย์อิสระที่ 2
    
    เลือกกลุ่มเป้าหมายที่เพิ่งสร้างขึ้น แล้วคลิกแท็บเป้าหมาย 
    
    - คลิกแก้ไข
    - เลือกอินสแตนซ์ EC2 ของคอมพิวเตอร์เกตเวย์อิสระที่ 2 แล้วคลิกเพิ่มไปยังลงทะเบียนแล้ว จากนั้นคลิกบันทึก