Python脚本如何生成Redash配置

wen 实用脚本 2026-07-03 188

本文目录导读：

基础配置生成脚本
带数据库配置的生成器
Kubernetes配置生成器
使用PyYAML的配置文件生成器
使用方法

我来为您介绍几种生成Redash配置的Python脚本方法：

基础配置生成脚本

#!/usr/bin/env python3
import json
import yaml
import os
from typing import Dict, Any
class RedashConfigGenerator:
    def __init__(self):
        self.config = {
            "REDASH_LOG_LEVEL": "INFO",
            "REDASH_REDIS_URL": "redis://localhost:6379/0",
            "REDASH_DATABASE_URL": "postgresql://postgres:password@localhost/redash",
            "REDASH_COOKIE_SECRET": self._generate_secret(),
            "REDASH_SECRET_KEY": self._generate_secret()
        }
    def _generate_secret(self, length=32):
        """生成随机密钥"""
        import secrets
        import string
        alphabet = string.ascii_letters + string.digits
        return ''.join(secrets.choice(alphabet) for _ in range(length))
    def generate_env_file(self, output_path=".env"):
        """生成.env文件"""
        with open(output_path, 'w') as f:
            for key, value in self.config.items():
                f.write(f"{key}={value}\n")
        print(f"生成的.env文件: {output_path}")
    def generate_docker_env(self, output_path="docker-compose.yml"):
        """生成docker-compose配置"""
        docker_config = {
            "version": "3.8",
            "services": {
                "redash-server": {
                    "image": "redash/redash:latest",
                    "ports": ["5000:5000"],
                    "environment": self.config,
                    "depends_on": ["postgres", "redis"]
                },
                "redash-worker": {
                    "image": "redash/redash:latest",
                    "command": "worker",
                    "environment": self.config,
                    "depends_on": ["postgres", "redis"]
                },
                "postgres": {
                    "image": "postgres:13",
                    "environment": {
                        "POSTGRES_PASSWORD": "password",
                        "POSTGRES_DB": "redash"
                    },
                    "volumes": ["postgres-data:/var/lib/postgresql/data"]
                },
                "redis": {
                    "image": "redis:6-alpine"
                }
            },
            "volumes": {
                "postgres-data": {}
            }
        }
        with open(output_path, 'w') as f:
            yaml.dump(docker_config, f, default_flow_style=False)
        print(f"生成的docker-compose文件: {output_path}")
# 使用示例
if __name__ == "__main__":
    generator = RedashConfigGenerator()
    generator.generate_env_file()
    generator.generate_docker_env()

带数据库配置的生成器

#!/usr/bin/env python3
import argparse
import os
class AdvancedRedashConfig:
    """高级Redash配置生成器"""
    TEMPLATES = {
        "production": {
            "REDASH_LOG_LEVEL": "WARNING",
            "REDASH_REDIS_URL": "redis://redis:6379/0",
            "REDASH_DATABASE_URL": "postgresql://redash:password@postgres/redash",
            "REDASH_RATE_LIMIT_ENABLED": "true",
            "REDASH_ENFORCE_HTTPS": "true"
        },
        "development": {
            "REDASH_LOG_LEVEL": "DEBUG",
            "REDASH_REDIS_URL": "redis://localhost:6379/0",
            "REDASH_DATABASE_URL": "postgresql://postgres:password@localhost/redash",
            "REDASH_RATE_LIMIT_ENABLED": "false",
            "REDASH_ENFORCE_HTTPS": "false"
        }
    }
    def __init__(self, env_type="development"):
        self.env_type = env_type
        self.config = self.TEMPLATES.get(env_type, self.TEMPLATES["development"]).copy()
        self.config["REDASH_COOKIE_SECRET"] = self._generate_secret()
        self.config["REDASH_SECRET_KEY"] = self._generate_secret()
        self.config["REDASH_MAIL_SERVER"] = "smtp.example.com"
        self.config["REDASH_MAIL_PORT"] = "587"
        self.config["REDASH_MAIL_USE_TLS"] = "true"
        self.config["REDASH_MAIL_USERNAME"] = ""
        self.config["REDASH_MAIL_PASSWORD"] = ""
        self.config["REDASH_MAIL_DEFAULT_SENDER"] = "no-reply@example.com"
    def _generate_secret(self):
        """生成安全密钥"""
        import hashlib
        import time
        return hashlib.sha256(str(time.time()).encode()).hexdigest()[:32]
    def to_env_file(self, filename=".env"):
        """生成.env文件"""
        with open(filename, 'w') as f:
            f.write(f"# Redash {self.env_type} Configuration\n")
            f.write(f"# Generated: {os.popen('date').read().strip()}\n\n")
            for key, value in self.config.items():
                if value and not value.startswith(('$', '{{')):
                    f.write(f"{key}={value}\n")
                else:
                    f.write(f"# {key} (required)\n")
        print(f"配置已生成到 {filename}")
    def to_json(self):
        """生成JSON格式配置"""
        return json.dumps(self.config, indent=2, default=str)
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="生成Redash配置")
    parser.add_argument("--env", choices=["production", "development"], default="development")
    parser.add_argument("--output", default=".env")
    args = parser.parse_args()
    config = AdvancedRedashConfig(args.env)
    config.to_env_file(args.output)

Kubernetes配置生成器

#!/usr/bin/env python3
import yaml
class RedashK8sConfig:
    """生成Kubernetes配置"""
    def generate_secret(self, namespace="redash"):
        """生成K8s Secret"""
        secret = {
            "apiVersion": "v1",
            "kind": "Secret",
            "metadata": {
                "name": "redash-secret",
                "namespace": namespace
            },
            "type": "Opaque",
            "stringData": {
                "cookie-secret": self._generate_secret(),
                "secret-key": self._generate_secret(),
                "database-url": "postgresql://redash:password@postgres/redash",
                "redis-url": "redis://redis:6379/0"
            }
        }
        return secret
    def generate_configmap(self, namespace="redash"):
        """生成ConfigMap"""
        configmap = {
            "apiVersion": "v1",
            "kind": "ConfigMap",
            "metadata": {
                "name": "redash-config",
                "namespace": namespace
            },
            "data": {
                "redash-log-level": "INFO",
                "redash-workers": "2",
                "redash-scheme": "https",
                "redash-host": "redash.example.com"
            }
        }
        return configmap
    def generate_deployment(self, namespace="redash"):
        """生成Deployment配置"""
        deployment = {
            "apiVersion": "apps/v1",
            "kind": "Deployment",
            "metadata": {
                "name": "redash-server",
                "namespace": namespace,
                "labels": {"app": "redash", "component": "server"}
            },
            "spec": {
                "replicas": 2,
                "selector": {
                    "matchLabels": {
                        "app": "redash",
                        "component": "server"
                    }
                },
                "template": {
                    "metadata": {
                        "labels": {
                            "app": "redash",
                            "component": "server"
                        }
                    },
                    "spec": {
                        "containers": [{
                            "name": "redash-server",
                            "image": "redash/redash:latest",
                            "ports": [{"containerPort": 5000}],
                            "envFrom": [
                                {"secretRef": {"name": "redash-secret"}},
                                {"configMapRef": {"name": "redash-config"}}
                            ],
                            "command": ["/app/bin/docker-entrypoint"],
                            "args": ["server"]
                        }]
                    }
                }
            }
        }
        return deployment
    def save_all(self, output_dir="k8s-config"):
        """保存所有K8s配置"""
        import os
        os.makedirs(output_dir, exist_ok=True)
        configs = {
            "secret.yaml": self.generate_secret(),
            "configmap.yaml": self.generate_configmap(),
            "deployment.yaml": self.generate_deployment(),
        }
        for filename, config in configs.items():
            filepath = os.path.join(output_dir, filename)
            with open(filepath, 'w') as f:
                yaml.dump(config, f, default_flow_style=False)
            print(f"生成: {filepath}")
if __name__ == "__main__":
    k8s_config = RedashK8sConfig()
    k8s_config.save_all()

使用PyYAML的配置文件生成器

#!/usr/bin/env python3
import yaml
import json
import os
def generate_redash_config(output_format='env'):
    """
    生成Redash配置文件
    支持格式: env, yaml, json
    """
    config = {
        'LOG_LEVEL': 'INFO',
        'DATABASE_URL': 'postgresql://postgres:password@localhost/redash',
        'REDIS_URL': 'redis://localhost:6379/0',
        'COOKIE_SECRET': None,  # 需要设置
        'SECRET_KEY': None,     # 需要设置
        'MAIL_SERVER': 'smtp.example.com',
        'MAIL_PORT': 587,
        'MAIL_USE_TLS': True,
        'MAIL_USERNAME': '',
        'MAIL_PASSWORD': '',
        'MAIL_DEFAULT_SENDER': 'noreply@example.com',
        'HOST': '0.0.0.0',
        'PORT': 5000,
        'WORKERS_COUNT': 4,
        'CORS_ACCESS_CONTROL_ALLOW_ORIGIN': '*',
        'ENFORCE_HTTPS': False,
        'RATE_LIMIT_ENABLED': False
    }
    if output_format == 'env':
        output = ""
        for key, value in config.items():
            if value is not None:
                output += f"REDASH_{key}={value}\n"
            else:
                output += f"# REDASH_{key} (required)\n"
        return output
    elif output_format == 'yaml':
        yaml_config = {f"REDASH_{k}": v for k, v in config.items()}
        return yaml.dump({'config': yaml_config}, default_flow_style=False)
    elif output_format == 'json':
        json_config = {f"REDASH_{k}": v for k, v in config.items()}
        return json.dumps(json_config, indent=2, default=str)
    return None
# 使用示例
if __name__ == "__main__":
    # 生成.env文件
    env_config = generate_redash_config('env')
    with open('.env', 'w') as f:
        f.write(env_config)
    # 生成YAML配置
    yaml_config = generate_redash_config('yaml')
    with open('redash-config.yml', 'w') as f:
        f.write(yaml_config)
    print("配置文件已生成！")

使用方法

基本使用：
```
python3 redash_config_generator.py
```

指定环境：

python3 advanced_config.py --env production --output .env.prod

生成K8s配置：
```
python3 k8s_config.py
```

这些脚本可以帮助您快速生成Redash所需的配置文件,包括：

.env 环境变量文件
Docker Compose配置
Kubernetes部署配置
不同环境的配置模板

根据您的实际需求选择合适的生成器,并修改数据库密码、邮件配置等敏感信息。

本文地址： https://www.bmjup.com/post/15134.html