Skip to main content

ConfigMaps w CGC SDK

Przegląd​

config_maps_data pozwala na przekazywanie danych konfiguracji do kontenerów w formie Kubernetes ConfigMaps. Jest to alternatywa dla zmiennych środowiskowych (environment_data) – zamiast przekazywać pojedyncze klucze, możesz przekazywać całe słowniki danych konfiguracji.

Format danych​

config_maps_data przyjmuje listę stringów w formacie:

"NAZWA_CONFIG_MAP=JSON_DANE"

Gdzie:

  • NAZWA_CONFIG_MAP – nazwa ConfigMap w Kubernetes
  • JSON_DANE – string w formacie JSON reprezentujący słownik { "klucz": "wartość", ... }

Przykład formatu:​

config_maps_data=[
    "app-config={\"DATABASE_URL\": \"postgres://db:5432\", \"CACHE_TTL\": \"3600\"}",
    "feature-flags={\"ENABLE_NEW_UI\": \"true\", \"MAX_RETRIES\": \"3\"}"
]

Jak to działa w kodzie​

Parsing danych​

Kod przetwarza config_maps_data w następujący sposób:

config_maps_data_dict = {}
for config_map in config_maps_data:
    key, value = config_map.split("=")  # Rozdziela nazwę od danych
    config_maps_data_dict[key] = value  # value powinno być JSON stringiem
payload["config_maps_data"] = config_maps_data_dict

Ważne: Wartość po = jest przekazywana jako string – backend sam parsuje go jako JSON.

Przykłady użycia​

Przykład 1: Podstawowe użycie z resource_create()​

import cgc.sdk.resource as resource

response = resource.resource_create(
    name="my-app-with-config",
    image_name="python:3.9",
    cpu=2,
    memory=4,
    config_maps_data=[
        "app-settings={\"LOG_LEVEL\": \"info\", \"DEBUG\": \"false\"}",
        "database-config={\"DB_HOST\": \"postgres\", \"DB_PORT\": \"5432\"}"
    ]
)

Przykład 2: Zmienna środowiskowa vs ConfigMap​

Zmienna środowiskowa (prosta):

environment_data=[
    "LOG_LEVEL=info",
    "DEBUG=false"
]

ConfigMap (strukturalna):

config_maps_data=[
    "logging-config={\"LOG_LEVEL\": \"info\", \"LOG_FORMAT\": \"json\", \"LOG_OUTPUT\": \"/var/log/app.log\"}"
]

Przykład 3: Kompleksowy przykład z wieloma ConfigMap​

import cgc.sdk.resource as resource
import json

# Przygotowanie danych konfiguracji
app_config = {
    "API_URL": "https://api.example.com",
    "TIMEOUT": "30",
    "MAX_CONNECTIONS": "100"
}

db_config = {
    "DB_HOST": "postgres.default.svc",
    "DB_PORT": "5432",
    "DB_NAME": "myapp",
    "DB_POOL_SIZE": "10"
}

feature_flags = {
    "ENABLE_CACHE": "true",
    "CACHE_TTL": "3600",
    "ENABLE_METRICS": "true"
}

response = resource.resource_create(
    name="production-app",
    image_name="my-registry/app:v1.2.3",
    cpu=4,
    memory=8,
    gpu=0,
    environment_data=[
        "ENV=production",
        "APP_VERSION=1.2.3"
    ],
    config_maps_data=[
        f"app-config={json.dumps(app_config)}",
        f"database-config={json.dumps(db_config)}",
        f"features={json.dumps(feature_flags)}"
    ],
    startup_command="python main.py"
)

if response['code'] == 200:
    print("✓ Aplikacja uruchomiona z ConfigMaps")
else:
    print(f"✗ Błąd: {response.get('message')}")

Przykład 4: Użycie z jobami (job_create())​

import cgc.sdk.job as job
import json

batch_config = {
    "BATCH_SIZE": "1000",
    "RETRY_COUNT": "3",
    "OUTPUT_FORMAT": "parquet"
}

response = job.job_create(
    name="data-processing-batch",
    image_name="my-registry/batch-processor:latest",
    cpu=2,
    memory=4,
    startup_command="python process_batch.py",
    config_maps_data=[
        f"batch-settings={json.dumps(batch_config)}"
    ],
    ttl_seconds_after_finished=7200  # Czyszczenie po 2h
)

Jak dostępna jest konfiguracja w kontenerze​

W kontenerze Kubernetes, ConfigMaps są domyślnie montowane jako pliki w katalogu /etc/config/ lub jako zmienne środowiskowe, w zależności od konfiguracji deploymentu.

Opcja A: Jako pliki (domyślne)​

/etc/config/app-config       # Zawartość: {"API_URL": "...", ...}
/etc/config/database-config  # Zawartość: {"DB_HOST": "...", ...}

Opcja B: Jako zmienne środowiskowe (jeśli skonfigurowane)​

echo $app-config  # {"API_URL": "...", ...}

Uwaga: Dokładny sposób montowania zależy od szablonu deploymentu używanego przez CGC. Sprawdź dokumentację cgc-server lub zapytaj o szczegóły montowania ConfigMaps w Twoim namespace.

Najczęstsze błędy​

❌ Błąd 1: Niepoprawny format JSON​

# ZŁE - brak cudzysłowów w JSON
config_maps_data=[
    "app-config={LOG_LEVEL: info}"  # ❌ Niepoprawny JSON
]

# DOBRE - poprawny JSON string
config_maps_data=[
    "app-config={\"LOG_LEVEL\": \"info\"}"  # ✅ Poprawny
]

❌ Błąd 2: Brak równań =​

# ZŁE
config_maps_data=[
    "app-config{\"LOG_LEVEL\": \"info\"}"  # ❌ Brakuje '='
]

# DOBRE
config_maps_data=[
    "app-config={\"LOG_LEVEL\": \"info\"}"  # ✅
]

❌ Błąd 3: Niepoprawne escapeowanie w Python​

# ZŁE - cudzysłowy konflikt
config_maps_data=[
    "app-config={"LOG_LEVEL": "info"}"  # ❌ SyntaxError
]

# DOBRE - użyj json.dumps() lub escapeuj
import json
config_maps_data=[
    f"app-config={json.dumps({'LOG_LEVEL': 'info'})}"  # ✅
]
# LUB
config_maps_data=[
    "app-config={\\\"LOG_LEVEL\\\": \\\"info\\\"}"  # ✅
]

Porównanie: environment_data vs config_maps_data​

Cechaenvironment_dataconfig_maps_data
FormatKLUCZ=WARTOŚĆNAZWA={JSON_DANE}
StrukturaPłaski słownikZagnieżdżone słowniki
OrganizacjaWszystkie zmienne razemPogrupowane tematycznie
CzytelnośćDobra dla prostych konfiguracjiLepsza dla złożonych
Przykład["LOG_LEVEL=info", "DEBUG=false"]["logging={\"LOG_LEVEL\": \"info\", \"DEBUG\": \"false\"}"]
ZastosowanieProste zmienne środowiskoweSkomplikowane konfiguracje, pliki config

Best Practices​

  1. Używaj json.dumps() do generowania JSON:

    import json
    config_maps_data=[
        f"my-config={json.dumps({'KEY': 'value'})}"
    ]

  2. Grupuj konfigurację tematycznie:

    config_maps_data=[
        "database={...}",
        "cache={...}",
        "logging={...}"
    ]

  3. Unikaj przechowywania sekretów w ConfigMaps – użyj Kubernetes Secrets zamiast tego.

  4. Waliduj JSON przed wysłaniem:

    import json
    try:
        json.dumps(my_dict)  # Walidacja
    except TypeError as e:
        print(f"Niepoprawny format: {e}")

Podsumowanie​

config_maps_data to potężne narzędzie do przekazywania strukturalnych danych konfiguracji do kontenerów w CGC. Używaj go, gdy:

  • Masz złożone konfiguracje z wieloma powiązanymi kluczami
  • Chcesz pogrupować konfigurację tematycznie
  • Potrzebujesz przekazać dane w formacie JSON/XML/YAML

Dla prostych zmiennych środowiskowych nadal używaj environment_data.

Źródła: Analiza kodu cgc-client:

  • cgc/commands/jobs/job_utils.py (linie 123-137)
  • cgc/commands/compute/compute_utils.py (linie 310-324)
  • cgc/sdk/resource.py (linie 254, 326, 362-363)
  • cgc/sdk/examples/basic_compute.py