การติดตั้ง Apache Superset

8 min readOct 30, 2023

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

Apache Superset เปิดให้ใช้งานแบบ open source ทำให้ผู้ใช้สามารถสำรวจ สร้างและแชร์แดชบอร์ดและรายงานข้อมูลได้เป็นอย่างดี การเริ่มต้นใช้งาน Apache Superset มีหลายขั้นตอน ต่อไปนี้คือขั้นตอนทั่วไปในการติดตั้งและปรับแต่ง Superset ให้ใช้งานได้:

ติดตั้ง Apache Superset:

ให้ติดตั้ง Apache Superset ในเซิร์ฟเวอร์หรือในเครื่องคอมพิวเตอร์ของคุณ
การติดตั้ง Apache Superset Locally โดยใช้ Docker Compose
การติดตั้ง Apache Superset บน Kubernetes
การตั้งค่า Config ใน Apache Superset

ตั้งค่าฐานข้อมูล:

คอนฟิกเชื่อมต่อ Superset กับฐานข้อมูลของคุณ
Superset สามารถเชื่อมต่อกับหลาย ๆ ฐานข้อมูลเช่น PostgreSQL, MySQL, Redshift, BigQuery, SQLite, และอื่น ๆ

สร้างชั้นข้อมูล:

ให้นิยามชั้นข้อมูล (Datasources) ใน Superset โดยการนำเข้าตารางข้อมูลหรือการสร้าง SQL Lab Views

สร้าง Slice และ Dashboard:

สร้าง Slice ซึ่งเป็นการวิเคราะห์ข้อมูลที่บันทึกไว้
นำ Slice ที่สร้างแล้วมาสร้าง Dashboard

การแชร์และการเข้าถึง:

กำหนดสิทธิ์ในการเข้าถึงให้กับผู้ใช้ต่าง ๆ
แชร์ Dashboard หรือ Slice ที่สร้างไว้ให้กับทีมหรือผู้ใช้งานอื่น ๆ

ปรับแต่ง:

ปรับแต่ง Superset ให้ตรงตามความต้องการของคุณ, เช่น เปลี่ยนหน้าตา, ปรับแต่งการตั้งค่า, หรือการพัฒนาปลั๊กอิน

การตรวจสอบและการแก้ไขปัญหา:

ตรวจสอบ logs และการตั้งค่าระบบเพื่อแก้ไขปัญหาที่อาจจะเกิดขึ้น

การเริ่มต้นใช้งาน Apache Superset อาจจะต้องการความรู้ทางด้านการจัดการฐานข้อมูลและการพัฒนาเว็บ แต่ทว่า, มีชุมชนและเอกสารปรับปรุงที่จะช่วยให้คุณสามารถเรียนรู้และทำความเข้าใจในการใช้งาน Superset ได้.

ติดตั้ง Apache Superset Locally โดยใช้ Docker Compose

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

การตรวจสอบก่อนติดตั้ง:

ตรวจสอบให้แน่ใจว่าคุณมี Docker และ Docker Compose ที่ติดตั้งในระบบของคุณ สามารถตรวจสอบเวอร์ชั่นของทั้งสองโปรแกรมนี้ได้โดยใช้คำสั่ง docker --version และ docker-compose --version ใน terminal.

การดาวน์โหลดไฟล์ Docker Compose:

ดาวน์โหลดไฟล์ docker-compose-non-dev.yml จากเอกสารการติดตั้ง Apache Superset และบันทึกไฟล์นี้ในไดเรกทอรีที่คุณต้องการใช้งาน.

การตั้งชื่อไฟล์และการปรับแต่ง:

เปลี่ยนชื่อไฟล์ docker-compose-non-dev.yml เป็น docker-compose.yml. นอกจากนี้, คุณยังสามารถปรับแต่งการตั้งค่าในไฟล์นี้ให้ตรงตามความต้องการของคุณ.

การเริ่มต้น Superset:

เปิด terminal แล้วนำทางไปยังไดเรกทอรีที่มีไฟล์ docker-compose.yml ที่คุณเพิ่งเปลี่ยนชื่อ จากนั้นใช้คำสั่ง docker-compose up ในการเริ่มต้น Superset.

การเข้าถึง Superset:

หลังจากที่ Superset เริ่มทำงานแล้ว, เปิดเว็บเบราว์เซอร์และไปที่ที่อยู่ http://localhost:8088. คุณจะต้องใช้ชื่อผู้ใช้ admin และรหัสผ่าน admin ในการลงชื่อเข้าใช้ในครั้งแรก.

การปรับแต่ง Superset:

เมื่อคุณลงชื่อเข้าใช้แล้ว, คุณสามารถเริ่มต้นการปรับแต่ง Superset ให้ตรงตามความต้องการของคุณ โดยการเชื่อมต่อกับฐานข้อมูล, สร้างชั้นข้อมูล, และสร้าง dashboard และ slices.

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

การติดตั้ง Apache Superset บน Kubernetes

การติดตั้ง Apache Superset บน Kubernetes ต้องใช้ Helm ในการจัดการ Deployment. ขั้นตอนหลักๆ ได้แก่:

เพิ่ม Repository ของ Superset ใน Helm:

helm repo add superset https://apache.github.io/superset

ตรวจสอบ Chart ที่มีอยู่ใน Repo:

helm search repo superset

ปรับแต่งการตั้งค่า โดยสร้างไฟล์ values.yaml ที่จะกำหนดหรือแทนที่ค่าต่างๆ ที่มีอยู่ในไฟล์ values.yaml พื้นฐาน.

ติดตั้งและเริ่มต้น Superset:

helm upgrade --install --values my-values.yaml superset superset/superset

เข้าถึง Superset: หลังจากติดตั้ง, คุณสามารถกำหนดการเข้าถึง Superset ได้หลายวิธี, ตัวอย่างเช่น, การกำหนด Service เป็น LoadBalancer หรือ NodePort, หรือการตั้งค่า Ingress.

ใช้คำสั่ง kubectl port-forward superset-xxxx-yyyy :8088 ในการเข้าถึง Superset UI จากภายนอก Kubernetes cluster.

ลงชื่อเข้าใช้: ใช้ username admin และ password admin ในการลงชื่อเข้าใช้ Superset ครั้งแรก

หากต้องการรายละเอียดเพิ่มเติม, กรุณาไปที่ ลิงค์นี้.

การ load examples ใน Apache Superset

เริ่มจาก docker ps เพื่อหา id ของ container ที่ชื่อ superset_app

ใช้คำสั่ง

docker exec -it {container-id} bash

จากนั้นใช้คำสั่ง

$ superset load_examples

เพื่อ load example

การตั้งค่าบัญชีผู้ดูแลระบบ

ในบางครั้ง เมื่อติดตั้ง superset จะพบว่าไม่สามารถ login เข้าระบบได้ ให้ใช้คำสั่งนี้เพื่อสร้าง admin account ขึ้นมา โดยใช้คำสั่งนี้

$ docker exec -it superset_app superset fab create-admin \
              --username admin \
              --firstname Superset \
              --lastname Admin \
              --email admin@superset.com \
              --password admin

$ docker exec -it superset_app superset db upgrade

$ docker exec -it superset_app superset init

คำสั่งนี้ใช้สำหรับสร้างผู้ดูแลระบบ (admin) ในแอปพลิเคชัน Superset

การตั้งค่า Config ใน Apache Superset

การตั้งค่า Apache Superset สามารถทำได้โดยการสร้างไฟล์ superset_config.py และกำหนดค่าต่างๆ ในไฟล์นี้.

ตัวอย่างเช่น หากใช้งาน Superset บน Linux จะสามารถกำหนดโดยตรงได้ที่ superset_config.py ของคุณอยู่ภายใต้ไดเร็กทอรี /app คุณสามารถเรียกใช้:

export SUPERSET_CONFIG_PATH=/app/superset_config.py

หากคุณใช้ Dockerfile ที่คุณกำหนดเองในอิมเมจทางการของ Superset เป็นอิมเมจพื้นฐาน คุณสามารถเพิ่มconfig เข้าไปแทนที่ได้ดังที่แสดงด้านล่าง:

COPY --chown=superset superset_config.py /app/
ENV SUPERSET_CONFIG_PATH /app/superset_config.py

ตัวอย่างของพารามิเตอร์บางส่วนที่สามารถตั้งค่าในไฟล์ superset_config.py ของคุณ:

# Superset specific config
ROW_LIMIT = 5000

# Flask App Builder configuration
# Your App secret key will be used for securely signing the session cookie
# and encrypting sensitive information on the database
# Make sure you are changing this key for your deployment with a strong key.
# Alternatively you can set it with `SUPERSET_SECRET_KEY` environment variable.
# You MUST set this for production environments or the server will not refuse
# to start and you will see an error in the logs accordingly.
SECRET_KEY = 'YOUR_OWN_RANDOM_GENERATED_SECRET_KEY'

# The SQLAlchemy connection string to your database backend
# This connection defines the path to the database that stores your
# superset metadata (slices, connections, tables, dashboards, ...).
# Note that the connection information to connect to the datasources
# you want to explore are managed directly in the web UI
# The check_same_thread=false property ensures the sqlite client does not attempt
# to enforce single-threaded access, which may be problematic in some edge cases
SQLALCHEMY_DATABASE_URI = 'sqlite:////path/to/superset.db?check_same_thread=false'

# Flask-WTF flag for CSRF
WTF_CSRF_ENABLED = True
# Add endpoints that need to be exempt from CSRF protection
WTF_CSRF_EXEMPT_LIST = []
# A CSRF token that expires in 1 year
WTF_CSRF_TIME_LIMIT = 60 * 60 * 24 * 365

# Set this API key to enable Mapbox visualizations
MAPBOX_API_KEY = ''

คุณสามารถกำหนดค่าสำหรับการเชื่อมต่อฐานข้อมูล, กำหนดค่าสำหรับ CSRF, และกำหนดค่าอื่นๆ ตามต้องการ. นอกจากนี้, การกำหนดค่า SECRET_KEY ยังเป็นสิ่งจำเป็นสำหรับการเริ่มต้น Superset. หากคุณต้องการเปลี่ยน SECRET_KEY ที่มีอยู่, คุณสามารถทำได้โดยการเพิ่มค่าเดิมและค่าใหม่ใน superset_config.py และจากนั้นเรียกใช้คำสั่ง superset re-encrypt-secrets

พารามิเตอร์และค่าเริ่มต้นทั้งหมดที่กำหนดไว้จะอยู่ที่ https://github.com/apache/superset/blob/master/superset/config.py

ทั้งใน config.py นี้สามารถนำไปกำหนดค่าใน superset_config.py ได้

ตัวอย่างการ Config เพื่อนำไปใช้งานกับ React component “@superset-ui/embedded-sdk”

# ***************************************
# *** Custom for Embedded
# ***************************************

CORS_OPTIONS = {
 'supports_credentials': True,
 'allow_headers': ['*'],
 'resources':['*'],
 'origins': ['*']
}

PUBLIC_ROLE_LIKE = 'Public'

DEFAULT_FEATURE_FLAGS = {
    "DYNAMIC_PLUGINS": True,
    "ALERTS_ATTACH_REPORTS": True,
    "DASHBOARD_RBAC": True,
    "EMBEDDABLE_CHARTS": True,
    "EMBEDDED_SUPERSET": True,
    "ENABLE_TEMPLATE_PROCESSING": True,
    "LISTVIEWS_DEFAULT_CARD_VIEW": True,
    "SCHEDULED_QUERIES": True,
    "SQL_VALIDATORS_BY_ENGINE": True,
    "THUMBNAILS": True
}

GUEST_TOKEN_JWT_SECRET = "YOUR-SECRET"

SESSION_COOKIE_SAMESITE = 'Lax'
SESSION_COOKIE_SECURE = False 
SESSION_COOKIE_HTTPONLY = False

PUBLIC_ROLE_LIKE_GAMMA = True
ENABLE_PROXY_FIX = True

WTF_CSRF_ENABLED = False

ENABLE_CORS = True

OVERRIDE_HTTP_HEADERS = {'X-Frame-Options': 'ALLOWALL'}

TALISMAN_ENABLED = False

MAPBOX_API_KEY='MAPBOX-API-KEY'

อ่านเรื่อง Config เพิ่มเติมได้ที่ Configuring Superset | Superset (apache.org)

การกำหนด Networking Settings ใน Apache Superset

การตั้งค่าการเชื่อมต่อเครือข่ายใน Apache Superset สามารถทำได้ผ่านไฟล์ superset_config.py ในหัวข้อต่างๆ ดังนี้:

CORS (Cross-Origin Resource Sharing):
CORS คือมาตรการความปลอดภัยที่ให้เบราว์เซอร์อนุญาตให้เว็บแอปพลิเคชันเรียกข้อมูลจากโดเมนที่แตกต่างกัน.

ติดตั้ง dependency ผ่านคำสั่ง

pip install apache-superset[cors]

กำหนดค่า ENABLE_CORS เป็น True และ CORS_OPTIONS สำหรับตั้งค่า Flask-CORS

ใน Apache Superset, คุณสามารถตั้งค่า CORS โดยการติดตั้ง dependency และตั้งค่าคีย์ ENABLE_CORS และ CORS_OPTIONS ในไฟล์ superset_config.py. การตั้งค่านี้เพื่อให้ Superset สามารถแชร์ข้อมูลกับโดเมนอื่นๆ ได้โดยปลอดภัย.

เอกสาร https://flask-cors.corydolphin.com/en/latest/api.html#extension

Domain Sharding:

กำหนดค่า SUPERSET_WEBSERVER_DOMAINS หรือ SESSION_COOKIE_DOMAIN ใน superset_config.py สำหรับการเปิดใช้งาน domain sharding

Domain Sharding ใน Apache Superset เป็นการแบ่งการเรียกข้อมูลไปยังโดเมนหลายโดเมนเพื่อวิเคราะห์ประสิทธิภาพของการโหลดหน้า. ในบางกรณี, เมื่อมี slices มากกว่า 6 ใน dashboard, คำขอการเรียกข้อมูลอาจถูกคิวไว้และรอการเชื่อมต่อที่จะว่าง. Domain Sharding ช่วยแบ่งคำขอเหล่านี้ไปยังโดเมนต่าง ๆ เพื่อลดการคอยของคำขอและเพิ่มประสิทธิภาพการโหลดหน้า. ใน Superset, คุณสามารถตั้งค่า Domain Sharding ได้ผ่านคีย์ SUPERSET_WEBSERVER_DOMAINS หรือ SESSION_COOKIE_DOMAIN ในไฟล์ superset_config.py.

Middleware:

กำหนดค่า ADDITIONAL_MIDDLEWARE ใน superset_config.py สำหรับการเพิ่ม middleware ของคุณเอง.

Middleware ใน Apache Superset ให้คุณสามารถเพิ่ม logic หรือการประมวลผลเพิ่มเติมในระหว่างการสื่อสารของ client และ server. คุณสามารถกำหนด Middleware ของคุณเองได้โดยการอัพเดทคีย์ ADDITIONAL_MIDDLEWARE ในไฟล์ superset_config.py. Middleware นี้สามารถใช้ในการปรับปรุง authentication, authorization, หรือจัดการ headers และ responses อื่น ๆ ใน Superset

การทำ Caching ใน Apache Superset

Apache Superset มีความสามารถในการจัดเก็บข้อมูลชั่วคราวหรือ caching เพื่อเพิ่มประสิทธิภาพในการโหลดข้อมูลและแสดงผล. Caching ช่วยลดเวลาในการโหลดหน้าเว็บ และลดโหลดบนฐานข้อมูล ซึ่งทำให้ผู้ใช้ได้รับประสบการณ์ที่ดีขึ้นเมื่อใช้งาน Superset. ผ่านการตั้งค่าที่เหมาะสม, คุณสามารถควบคุมวิธีการและสิ่งที่จะถูกจัดเก็บใน cache, อย่างไรก็ตาม, การตั้งค่าเหล่านี้ต้องถูกกำหนดอย่างถูกต้องเพื่อปรับใช้ประสิทธิภาพที่ดีที่สุด

Caching

จะใช้ Flask-Caching การทำ Caching Flask-Caching รองรับการแคชที่หลากหลาย รวมไปถึงการใช้ Redis (แนะนำ), Memcached, SimpleCache (ในหน่วยความจำ) หรือระบบไฟล์ในเครื่อง

สามารถอ่านเรื่อง การ custom cache backends ใน Flask-Caching ได้ที่ Flask-Caching — Flask-Caching 1.0.0 documentation

สามารถกำหนด cache ได้ตามหัวข้อต่อไปนี้

Dashboard filter state (required): FILTER_STATE_CACHE_CONFIG.
Explore chart form data (required): EXPLORE_FORM_DATA_CACHE_CONFIG
Metadata cache (optional): CACHE_CONFIG
Charting data queried from datasets (optional): DATA_CACHE_CONFIG

ตัวอย่างเช่น หากต้องการกำหนดค่า filter state cacheโดยใช้ Redis:

FILTER_STATE_CACHE_CONFIG = {
    'CACHE_TYPE': 'RedisCache',
    'CACHE_DEFAULT_TIMEOUT': 86400,
    'CACHE_KEY_PREFIX': 'superset_filter_cache',
    'CACHE_REDIS_URL': 'redis://localhost:6379/0'
}

Dependencies

ในการใช้งาน Caching บน Apache Superset, คุณต้องติดตั้ง libraries ที่เพิ่มเติมเพื่อให้สามารถใช้งาน cache stores ที่ต้องการได้.

ตัวอย่างเช่น, หากคุณต้องการใช้ Redis สำหรับ caching, คุณควรติดตั้ง package ที่ชื่อ redis และในกรณีของ Memcached, ควรใช้ pylibmc เพราะ python-memcached ไม่สามารถจัดการ binary data ได้ถูกต้อง. คุณสามารถติดตั้ง libraries เหล่านี้ผ่าน pip

Fallback Metastore Cache

Fallback Metastore Cache ใน Apache Superset ทำหน้าที่เป็นการจัดเก็บข้อมูลชั่วคราวในกรณีที่ไม่มีการกำหนดค่า caching สำหรับ Filter State และ Explore. หากไม่มีการกำหนดค่าเหล่านี้, Superset จะใช้ built-in cache ที่จัดเก็บข้อมูลใน metadata database. ถึงแม้ว่าจะแนะนำให้ใช้ dedicated cache, แต่ built-in cache นี้ยังสามารถใช้งานได้เพื่อจัดเก็บข้อมูลชนิดอื่นๆ. ตัวอย่างเช่น, สำหรับการจัดเก็บข้อมูล chart คุณสามารถใช้การตั้งค่าต่อไปนี้:

DATA_CACHE_CONFIG = {
    "CACHE_TYPE": "SupersetMetastoreCache",
    "CACHE_KEY_PREFIX": "superset_results",  # make sure this string is unique to avoid collisions
    "CACHE_DEFAULT_TIMEOUT": 86400,  # 60 seconds * 60 minutes * 24 hours
}

การตั้งค่านี้จะทำให้ Superset ใช้ built-in cache ในการจัดเก็บข้อมูล chart.

Chart Cache Timeout

การตั้งค่า Chart Cache Timeout ใน Apache Superset ช่วยกำหนดระยะเวลาที่ data จะถูกเก็บใน cache ก่อนที่จะต้องเรียกข้อมูลใหม่จากฐานข้อมูล. ค่า timeout สามารถถูกแทนที่ได้โดยการตั้งค่าที่ chart, dataset, หรือ database level. หากไม่มีการแทนที่ค่า, ค่า timeout ดีฟอลต์ที่กำหนดใน DATA_CACHE_CONFIG จะถูกใช้. ในกรณีที่ต้องการปิดใช้งาน caching สำหรับข้อมูลการ charting, คุณสามารถตั้งค่า cache timeout เป็น -1 ที่ chart, dataset หรือ database level, หรือตั้งค่านี้ใน DATA_CACHE_CONFIG.

SQL Lab Query Results

ในหัวข้อ SQL Lab Query Results, caching ใช้สำหรับเก็บผลลัพธ์ของการ query ใน SQL Lab เมื่อมีการใช้งาน async queries. การตั้งค่านี้ไม่ใช้ dictionary ของ flask-caching สำหรับการตั้งค่า, แต่ใช้ cachelib object แทน. การตั้งค่านี้ต้องการการกำหนดค่า RESULTS_BACKEND ในไฟล์ superset_config.py. สำหรับรายละเอียดเพิ่มเติม, คุณสามารถดูได้ที่หัวข้อ Async Queries via Celery ในเอกสารการตั้งค่า Apache Superset.

Caching Thumbnails

ใน Apache Superset, คุณสามารถเปิดใช้งาน caching สำหรับ thumbnails โดยการตั้งค่า feature flag. คุณต้องตั้งค่า FEATURE_FLAGS ใน superset_config.py และเปิดใช้งาน THUMBNAILS และ THUMBNAILS_SQLA_LISTENERS. Thumbnails จะถูกสร้างตามผู้ใช้และจัดเก็บใน cache. การประมวลผล thumbnails นี้ทำโดย celery workers และทั้งหมดจะถูกจัดเก็บใน cache. คุณสามารถกำหนดค่าต่างๆ เช่น ที่จัดเก็บ cache, user ที่ใช้ในการสร้าง thumbnail, และการตั้งค่า selenium web driver ได้ตามต้องการ

การเปิดใช้งาน feature flag ให้กำหนดค่าดังนี้:

FEATURE_FLAGS = {
    "THUMBNAILS": True,
    "THUMBNAILS_SQLA_LISTENERS": True,
}

ดูรายละเอียดเพิ่มเติมเพื่อ config ได้ที่ Caching | Superset (apache.org)

การทำ Logging ใน Apache Superset

Apache Superset มีระบบ logging ที่ทรงพลังเพื่อจัดเก็บและติดตามกิจกรรมต่างๆ ที่เกิดขึ้นภายในแอปพลิเคชัน. ระบบ logging นี้ช่วยให้ผู้ดูแลระบบสามารถวิเคราะห์ปัญหา, ตรวจสอบการใช้งาน, และปรับปรุงประสิทธิภาพของระบบได้ง่ายขึ้น. ผ่านการตั้งค่าที่เหมาะสม, คุณสามารถกำหนดรายละเอียดของการ logging ได้ตามต้องการ, ทำให้ Superset สามารถปรับตัวเพื่อตอบสนองต่อความต้องการที่แตกต่างกันขององค์กร.

Event Logging

ใน Apache Superset, คุณสามารถปรับแต่งการ logging ของ event ได้ตามต้องการ. โดยปริยาย, Superset จะ log กิจกรรมพิเศษในฐานข้อมูลภายในของมัน (DBEventLogger). คุณสามารถทำให้ logs นี้สามารถเข้าถึงได้จาก UI โดยไปที่ Security > Action Log. โดยตัวอย่าง, ถ้าคุณต้องการ log events เป็น JSON ไปยัง stdout, คุณสามารถสร้าง class ของคุณเองที่ทำงานตามต้องการ, และอัพเดท superset_config.py ด้วย instance ของ logger ที่คุณต้องการใช้:

class JSONStdOutEventLogger:
    def log(self, user_id, action, *args, **kwargs):
        records = kwargs.get('records', list())
        dashboard_id = kwargs.get('dashboard_id')
        slice_id = kwargs.get('slice_id')
        duration_ms = kwargs.get('duration_ms')
        referrer = kwargs.get('referrer')

        for record in records:
            log = dict(
                action=action,
                json=record,
                dashboard_id=dashboard_id,
                slice_id=slice_id,
                duration_ms=duration_ms,
                referrer=referrer,
                user_id=user_id
            )
            print(json.dumps(log))

EVENT_LOGGER = JSONStdOutEventLogger()

จากโค้ดนี้สร้าง class ชื่อ JSONStdOutEventLogger ที่มีเมธอด log ในการจัดเก็บข้อมูล event. เมธอดนี้รับ arguments หลายตัว เช่น user_id, action, และ kwargs. มันดึงข้อมูลจาก kwargs และเตรียมข้อมูลเพื่อ logging. ใน loop, มันสร้าง dictionary ของข้อมูลที่จะ log และใช้ print(json.dumps(log)) เพื่อเขียน log ไปยัง stdout ในรูปแบบ JSON. สุดท้าย, มันสร้าง instance ของ JSONStdOutEventLogger และกำหนดให้กับ EVENT_LOGGER เพื่อให้ Superset ใช้ logger นี้ในการจัดเก็บ event.

StatsD Logging

ใน Apache Superset, คุณสามารถตั้งค่าการ logging กับ StatsD ได้. การตั้งค่านี้ทำให้ Superset สามารถ log events ที่เกิดขึ้นไปยัง StatsD, ซึ่งเป็นระบบสำหรับการจัดเก็บและประมวลผล metrics. ตัวอย่างการตั้งค่าการ logging ด้วย StatsD ใน superset_config.py มีดังนี้:

from superset.stats_logger import StatsdStatsLogger   
STATS_LOGGER = StatsdStatsLogger(host='localhost', port=8125, prefix='superset')

นอกจากนี้, คุณยังสามารถสร้าง logger ของคุณเองได้โดยการสืบทอดจาก superset.stats_logger.BaseStatsLogger.

StatsD เป็นระบบสำหรับส่ง, รวบรวม, และจัดเก็บ metrics ทางสถิติที่ใช้ในการติดตามและตรวจสอบประสิทธิภาพของระบบ. มันเป็นตัวกลางในการรับ metrics จากระบบต่างๆ แล้วส่งต่อไปยัง backends ที่สามารถจัดการข้อมูลนี้ได้. เครื่องมือนี้ทำให้ง่ายต่อการวิเคราะห์การทำงานของระบบในเวลาจริง.

การทำ Upgrading ใน Apache Superset

การปรับรุ่น Apache Superset สามารถทำได้ผ่าน Docker Compose หรือติดตั้งด้วยตนเอง. สำหรับ Docker Compose, ให้หยุด containers, อัปเดต repo ของ Superset และเริ่ม containers ใหม่.

docker compose down

จากนั้น

cd superset/
git pull origin master

จากนั้นรีสตาร์ทคอนเทนเนอร์และอิมเมจ Docker ที่เปลี่ยนแปลงจะถูกดึงลงมาโดยอัตโนมัติ:

docker compose up
# or
# docker compose up -d

สำหรับการติดตั้งด้วยตนเอง, ให้ใช้คำสั่ง pip และคำสั่ง superset ในการอัปเดต. แนะนำให้สำรองข้อมูลฐานข้อมูล metadata ก่อนการปรับรุ่น, และทดสอบการปรับรุ่นในสภาพแวดล้อม staging ก่อนที่จะปรับรุ่นในสภาพแวดล้อม production.

pip install apache-superset --upgrade
superset db upgrade
superset init

การทำ Async Queries ด้วย Celery ใน Apache Superset

การตั้งค่า Async Queries ผ่านทาง Celery ใน Apache Superset ช่วยให้คุณสามารถจัดการ queries ที่ซับซ้อนหรือใช้เวลานานในการประมวลผลได้อย่างมีประสิทธิภาพมากยิ่งขึ้น. Celery ทำหน้าที่เป็น distributed task queue ที่ช่วยจัดการการประมวลผลแบบ asynchronous ทำให้ Superset สามารถจัดการกับ workload ที่มากขึ้นและให้ประสบการณ์ที่ดีให้กับผู้ใช้.

สามารถติดตั้ง celery ได้จาก

pip install celery

#อ่านเพิ่มเติม: https://pypi.org/project/celery/

ในการตั้งค่า, คุณจำเป็นต้องติดตั้ง Celery และตั้งค่าใน superset_config.py. ต่อไปนี้คือตัวอย่างของการตั้งค่า:

from celery import Celery
from my_celery_config import CELERY_CONFIG

CELERY_APP = Celery(
    'superset',
    broker='redis://localhost:6379/0',
    backend='redis://localhost:6379/1',
    include=['superset.sql_lab', 'superset.tasks']
)
CELERY_APP.conf.update(CELERY_CONFIG)

ในตัวอย่างนี้, คุณต้องสร้าง instance ของ Celery และกำหนด broker และ backend เพื่อใช้งาน Redis. คุณต้องยังต้องระบุ modules ที่รวม tasks ที่คุณต้องการให้ Celery จัดการ.

นอกจากนี้, คุณต้องตั้งค่า Superset ให้ใช้งาน Celery สำหรับการประมวลผล query แบบ asynchronous โดยการเพิ่มตัวแปร RESULTS_BACKEND และ SQLLAB_CTAS_NO_LIMIT ใน superset_config.py:

RESULTS_BACKEND = ...
SQLLAB_CTAS_NO_LIMIT = ...

การตั้งค่า Async Queries ผ่าน Celery จะช่วยให้คุณสามารถทำงานกับ datasets ขนาดใหญ่ได้มีประสิทธิภาพมากยิ่งขึ้นและเพิ่มประสิทธิภาพของ Superset ได้อย่างมาก.

Celery Flower

Flower เป็นเครื่องมือบนเว็บสำหรับตรวจสอบคลัสเตอร์ Celery ซึ่งคุณสามารถติดตั้งได้จาก pip

pip install flower

คุณสามารถเรียกใช้ flower โดยใช้:

celery --app=superset.tasks.celery_app:app flower

Alerts and Reports ใน Apache Superset

การตั้งค่า Alerts และ Reports ใน Apache Superset ช่วยให้ผู้ใช้สามารถกำหนดการแจ้งเตือนอัตโนมัติและรายงานเพื่อส่งแดชบอร์ดหรือแผนภูมิไปยังผู้รับทางอีเมลหรือ Slack Ch. การตั้งค่านี้ต้องการการตั้งค่าเบื้องต้นทางด้านฮาร์ดแวร์และซอฟต์แวร์, ทำให้ผู้ใช้ต้องมีความเข้าใจเกี่ยวกับการตั้งค่าที่ต้องการ, ได้แก่การตั้งค่า Celery และการตั้งค่าการเชื่อมต่อ Slack หรือ SMTP สำหรับการส่งแจ้งเตือนและรายงาน

เพิ่มเติม: Alerts and Reports | Superset (apache.org)

การทำ SQL Templating ใน Apache Superset

การทำ SQL Templating ใน Apache Superset นั้นสามารถทำได้โดยใช้ Jinja Templates และ Macros ต่างๆ โดยจะต้องทำการเปิดใช้งาน ENABLE_TEMPLATE_PROCESSING feature flag ในไฟล์ superset_config.py

เพื่อให้สามารถใช้งาน templating ได้. Jinja templating ใน Superset นั้นจะสามารถใช้กับ SQL queries ใน SQL Lab และ Explore. นอกจากนี้ยังสามารถสร้าง custom functionality ใน Jinja context ได้โดยการใช้ JINJA_CONTEXT_ADDONS ในการกำหนด.

สำหรับหัวข้อ Available Macros นั้น ทำให้ผู้ใช้สามารถสร้าง macros เพื่อใช้ในการประมวลผล queries และยังมีตัวอย่างการสร้าง custom template processor สำหรับ database engine ต่างๆ ได้.

เพิ่มเติม: SQL Templating | Superset (apache.org)

การเชื่อมต่อ database ใน Apache Superset

การเชื่อมต่อ database ใน Apache Superset ทำได้โดยการใส่ connection string ของ database ที่ต้องการเชื่อมต่อในหน้าจอ ‘Add Database’ ที่อยู่ในเมนู ‘Data’ > ‘Databases’. คุณสามารถกำหนดค่าต่างๆ เช่น encryption, caching strategy, หรือ extra connection options ในหน้าจอนี้ได้. นอกจากนี้ยังมีตัวเลือกในการกำหนดค่า pooling และ timeouts ให้กับการเชื่อมต่อ database. Superset สนับสนุนหลายๆ database engine รวมถึง Postgres, MySQL, Redshift, BigQuery, Snowflake, SQLite, และอื่นๆ.

Database Drivers ใน Apache Superset

การติดตั้ง Database Drivers ใน Apache Superset ให้ความสำคัญต่อการเชื่อมต่อกับ databases ต่างๆ ที่ต้องการจะใช้งาน. Superset ต้องการ Python DB-API database driver และ SQLAlchemy dialect สำหรับแต่ละ datastore ที่ต้องการเชื่อมต่อ.

หัวข้อ Supported Databases and Dependencies บอกเกี่ยวกับ databases ที่ Apache Superset สามารถรองรับได้ และ dependencies ที่ต้องการในการติดตั้ง drivers. ต่อไปนี้คือรายชื่อ database ที่รองรับ:

Amazon Athena
Amazon DynamoDB
Amazon Redshift
Apache Drill
Apache Druid
Apache Hive
Apache Impala
Apache Kylin
Apache Pinot
Apache Solr
Apache Spark SQL
Ascend.io
Azure MS SQL
Big Query
ClickHouse
CockroachDB
Dremio
Elasticsearch
Exasol
Google Sheets
Firebolt
Hologres
MySQL
PostgreSQL

และยังมีอื่นๆ อีกมากมาย

คำสั่ง pip install จะใช้สำหรับการติดตั้ง drivers ต่างๆ เช่น ในกรณีของ Amazon Athena, คำสั่งคือ pip install pyathena[pandas] หรือ pip install PyAthenaJDBC. สำหรับ Amazon Redshift, คำสั่งคือ pip install sqlalchemy-redshift. นอกจากนี้ยังมี drivers อื่นๆ ที่สามารถติดตั้งได้ตามความต้องการของผู้ใช้.

Row Level Security (RLS)

Row Level Security (RLS) ใน Apache Superset ช่วยให้คุณสามารถสร้างตัวกรองที่สามารถกำหนดได้ตามตารางและกลุ่มบทบาทต่างๆ. ตัวอย่างเช่น, ถ้าคุณต้องการให้ทีมการเงินเข้าถึงเฉพาะแถวที่ department = "finance", คุณสามารถ:

สร้างตัวกรอง Row Level Security ด้วยเงื่อนไขนี้ (department = "finance")
จากนั้นกำหนดเงื่อนไขนี้ให้กับบทบาทของ Finance และตารางที่เกี่ยวข้อง

ตัวกรองที่สร้างขึ้นจะถูกเพิ่มไปในคำสั่ง SQL ที่สร้างขึ้นในส่วนของ WHERE clause. นอกจากนี้ยังสามารถสร้างเงื่อนไขที่มีหลายๆ เงื่อนไขได้เช่น client_id = 6 AND advertiser="foo" ฯลฯ. ทั้งหมดนี้จะช่วยให้คุณสามารถควบคุมการเข้าถึงข้อมูลในระดับแถวได้ตามบทบาทของผู้ใช้.