Direct script calling replaces start script

[kurmann]

• [x] Start-Script zur Eingabe der Konfigwerte wird gelöscht
• [x] CLI API mit argparse umsetzen
• [x] Supervisor-Script umsetzen

[kurmann]

Ja, genau! argparse übernimmt die Aufgabe, die Argumente zur Laufzeit des Skripts zu parsen und an die entsprechenden Funktionen weiterzuleiten. Dies ermöglicht eine flexible und saubere Handhabung der Kommandozeilenargumente, sodass verschiedene Skripte mit ihren spezifischen Parametern ausgeführt werden können.

Zusammengefasster Ablauf

1. argparse parst die Kommandozeilenargumente:

   • Das Supervisor-Skript verwendet argparse, um die Argumente aus der Kommandozeile zu lesen. Dabei wird der erste Parameter als Skriptname (script) und die restlichen Parameter als zusätzliche Argumente (args) behandelt.

2. AWS CLI Konfiguration:

   • Bevor das eigentliche Skript ausgeführt wird, konfiguriert das Supervisor-Skript die AWS CLI mit den Umgebungsvariablen.

3. Ausführung des gewünschten Skripts:

   • Basierend auf dem geparsten Skriptnamen und den zusätzlichen Argumenten führt das Supervisor-Skript das gewünschte Skript mit den entsprechenden Parametern aus.

Beispiel-Supervisor-Skript (supervisor.py)

Hier ist das vollständige Supervisor-Skript nochmals, das die Argumente parst und die entsprechenden Skripte mit ihren spezifischen Parametern ausführt:

import os
import subprocess
import sys
import argparse

def configure_aws():
    """Konfiguriert die AWS CLI mit Zugangsdaten aus Umgebungsvariablen."""
    aws_access_key_id = os.getenv('AWS_ACCESS_KEY_ID')
    aws_secret_access_key = os.getenv('AWS_SECRET_ACCESS_KEY')
    aws_default_region = os.getenv('AWS_DEFAULT_REGION', 'eu-west-1')

    if not aws_access_key_id or not aws_secret_access_key:
        print("AWS_ACCESS_KEY_ID oder AWS_SECRET_ACCESS_KEY ist nicht gesetzt.")
        print("Bitte setze die Umgebungsvariablen AWS_ACCESS_KEY_ID und AWS_SECRET_ACCESS_KEY.")
        return False

    try:
        subprocess.run(['aws', 'configure', 'set', 'aws_access_key_id', aws_access_key_id], check=True)
        subprocess.run(['aws', 'configure', 'set', 'aws_secret_access_key', aws_secret_access_key], check=True)
        subprocess.run(['aws', 'configure', 'set', 'region', aws_default_region], check=True)
        print("AWS CLI Konfiguration abgeschlossen.")
        return True
    except subprocess.CalledProcessError as e:
        print(f"Fehler bei der AWS CLI Konfiguration: {e}")
        return False

def run_script(script_name, args):
    script_path = f"/usr/src/app/scripts/{script_name}.py"
    if os.path.exists(script_path):
        command = ['python3', script_path] + args
        subprocess.run(command, check=True)
    else:
        print(f"Skript {script_name} existiert nicht.")

def main():
    parser = argparse.ArgumentParser(description="Supervisor für S3 Restore Utilities")
    parser.add_argument('script', type=str, help="Name des auszuführenden Skripts")
    parser.add_argument('args', nargs=argparse.REMAINDER, help="Zusätzliche Argumente für das Skript")
    args = parser.parse_args()

    if configure_aws():
        run_script(args.script, args.args)

if __name__ == "__main__":
    main()

Docker Compose File (docker-compose.yml)

Hier ist das docker-compose.yml, das das Supervisor-Skript als entrypoint konfiguriert:

version: '3.8'

services:
  s3-restore-utilities:
    image: kurmann/s3-restore-utilities:latest
    container_name: s3-restore-utilities
    volumes:
      - /volume1/docker/s3-restore-utilities/downloads:/usr/src/app/downloads
      - /volume1/docker/s3-restore-utilities/logs:/usr/src/app/logs
      - ./supervisor.py:/usr/local/bin/supervisor.py  # Bind mount das Supervisor-Skript
    env_file:
      - .env
    entrypoint: ["python3", "/usr/local/bin/supervisor.py"]
    tty: true
    stdin_open: true

volumes:
  downloads:
  logs:

Beispielaufrufe der Skripte

Hier sind einige Beispiele, wie du die verschiedenen Skripte mit den jeweiligen Parametern ausführen kannst:

• List Buckets Skript ausführen (ohne zusätzliche Parameter):

  docker-compose run s3-restore-utilities list_buckets

• Restore Deep Glacier Skript ausführen (mit zusätzlichen Parametern):

  docker-compose run s3-restore-utilities restore_deep_glacier dein-bucket-name pfad/zum/verzeichnis Bulk

• Check Restore Status Skript ausführen (mit zusätzlichen Parametern):

  docker-compose run s3-restore-utilities check_restore_status dein-bucket-name pfad/zum/verzeichnis

• Download S3 Directory Skript ausführen (mit zusätzlichen Parametern):

  docker-compose run s3-restore-utilities download_s3_directory dein-bucket-name pfad/zum/verzeichnis lokaler-pfad

Zusammenfassung

• Supervisor-Skript: Verwendet argparse, um die Argumente zu parsen und die entsprechenden Skripte mit den richtigen Parametern auszuführen.
• Docker Compose: Konfiguriert das entrypoint, um das Supervisor-Skript auszuführen.
• Flexibilität: Ermöglicht das flexible und benutzerfreundliche Ausführen verschiedener Skripte mit spezifischen Parametern.

Mit diesem Ansatz kannst du unterschiedliche Parameter für verschiedene Skripte angeben und sicherstellen, dass der Benutzer auf fehlende Parameter hingewiesen wird.

[kurmann]

Übersicht der Ansätze zur Ausführung und Verwaltung von Docker-Containern

1. Einmalige Ausführung vs. Dauerhafte Dienste

• Einmalige Ausführung:

  • Beschreibung: Container wird für eine bestimmte Aufgabe gestartet und beendet sich nach Abschluss der Aufgabe.
  • Beispiele:
  • Skript-basierte Containerisierung (Direktaufruf-Ansatz)
  • Batch-Jobs
  • Datenverarbeitung

• Dauerhafte Dienste:

  • Beschreibung: Container wird als langfristig laufender Dienst gestartet und bleibt aktiv, um kontinuierlich Anfragen zu verarbeiten.
  • Beispiele:
  • Webserver (z.B. Nginx, Apache)
  • Datenbanken (z.B. MySQL, PostgreSQL)
  • Anwendungen (z.B. Node.js, .NET Core)

2. Aufrufmethoden

• Über die Shell:

  • Beschreibung: Direkter Aufruf von Docker-Befehlen im Terminal.
  • Beispiele:
  • docker run
  • docker exec
  • docker-compose up
  • Nutzung:
    • Einmalige Ausführung: docker run my-container python3 script.py
    • Dauerhafte Dienste: docker run -d -p 80:80 my-webserver

• Über Netzwerk (Port-Aufrufe):

  • Beschreibung: Container stellt Dienste über definierte Ports bereit, auf die über das Netzwerk zugegriffen werden kann.
  • Beispiele:
  • Webanwendungen (Port 80 für HTTP, Port 443 für HTTPS)
  • APIs (z.B. RESTful APIs)
  • Datenbankzugriff (z.B. Port 3306 für MySQL)
  • Nutzung:
    • Dauerhafte Dienste: Container wird gestartet und bleibt aktiv, z.B. docker run -d -p 80:80 my-webserver, Zugriff über http://localhost.

3. Verwaltungstools

• Docker CLI:

  • Beschreibung: Kommandozeilenwerkzeug zur Verwaltung von Containern, Images, Netzwerken und Volumes.
  • Beispiele:
  • docker run: Startet einen neuen Container.
  • docker exec: Führt einen Befehl in einem laufenden Container aus.
  • docker stop: Stoppt einen laufenden Container.

• Docker Compose:

  • Beschreibung: Werkzeug zur Definition und Verwaltung von Multi-Container Docker-Anwendungen.
  • Beispiele:
  • docker-compose up: Startet alle definierten Dienste.
  • docker-compose down: Stoppt und entfernt alle definierten Dienste.
  • Nutzung:
    • Definieren von Multi-Container-Anwendungen in einer docker-compose.yml.

• Docker Swarm/Kubernetes:

  • Beschreibung: Orchestrierungstools zur Verwaltung von verteilten Container-Umgebungen.
  • Beispiele:
  • Docker Swarm: docker swarm init, docker service create
  • Kubernetes: kubectl apply, kubectl get pods
  • Nutzung:
    • Verwaltung von Container-Clustern, Skalierung, Ausfallsicherheit.

4. Zugriffsarten auf Container

• Direktzugriff:

  • Beschreibung: Direkter Zugriff auf den Container über die Shell oder durch API-Aufrufe.
  • Beispiele:
  • docker exec -it my-container /bin/sh
  • curl http://localhost:8080/api
  • Nutzung:
  • Fehlerbehebung, Verwaltung, Konfiguration.

• Indirekter Zugriff:

  • Beschreibung: Zugriff auf Container-Dienste über Netzwerkschnittstellen oder Ports.
  • Beispiele:
  • Webbrowser-Zugriff: http://localhost
  • Datenbank-Clients: MySQL Workbench, pgAdmin
  • Nutzung:
  • Benutzerinteraktion, Client-Server-Architekturen.

Zusammenfassung

1. Einmalige Ausführung vs. Dauerhafte Dienste:

   • Einmalige Ausführung: Container wird für eine spezifische Aufgabe gestartet und beendet sich danach.
   • Dauerhafte Dienste: Container läuft kontinuierlich, um Anfragen zu bearbeiten.

2. Aufrufmethoden:

   • Über die Shell: Direktes Ausführen von Befehlen im Terminal.
   • Über Netzwerk (Port-Aufrufe): Bereitstellung von Diensten über definierte Ports.

3. Verwaltungstools:

   • Docker CLI: Grundlegende Verwaltung von Containern und Ressourcen.
   • Docker Compose: Verwaltung von Multi-Container-Anwendungen.
   • Docker Swarm/Kubernetes: Orchestrierungstools für verteilte Container-Umgebungen.

4. Zugriffsarten auf Container:

   • Direktzugriff: Direkter Zugang zur Container-Shell oder über API-Aufrufe.
   • Indirekter Zugriff: Zugriff über Netzwerkschnittstellen und Ports.

Durch die Verwendung dieser Ansätze kannst du flexibel und effizient Container-Anwendungen entwickeln, bereitstellen und verwalten, unabhängig von der zugrunde liegenden Technologie oder dem spezifischen Anwendungsfall.