การติดตั้ง Apache Superset
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"
ฯลฯ. ทั้งหมดนี้จะช่วยให้คุณสามารถควบคุมการเข้าถึงข้อมูลในระดับแถวได้ตามบทบาทของผู้ใช้.