Skip to content

Containerisierung mit Docker

Jump to bottom
Maximilian Reiner edited this page Oct 24, 2024 · 1 revision

Containerisierung mit Docker

Autoren: @Lukas Ahlert und @Maximilian Reiner

1. Was ist Containerisierung?

  • Definition:

    • Containerisierung ist eine leichte Form der Virtualisierung, bei der eine Anwendung und ihre Abhängigkeiten in einen Container gepackt werden.
    • Diese Container können konsistent in verschiedenen Umgebungen laufen.

  • Wesentliche Merkmale:

    • Isolierte Umgebung: Jeder Container läuft in einer isolierten Umgebung mit eigenem Dateisystem, Prozessen und Netzwerk-Stack.
    • Leichtgewichtig: Container teilen sich den Kernel des Host-Betriebssystems, was sie effizienter als virtuelle Maschinen (VMs) macht.

  • Analogie:

    • Vergleiche die Containerisierung mit "Schiffscontainern" in der Logistik – standardisierte, portable Einheiten, die überall hin transportiert werden können, unabhängig davon, was sich darin befindet.

2. Warum ist Containerisierung wichtig?

  • Konsistenz zwischen Umgebungen:

    • Container stellen sicher, dass dieselbe Anwendung in Entwicklungs-, Test- und Produktionsumgebungen ohne das Problem "Es funktioniert auf meinem Rechner" läuft.

  • Vorteile:

    • Portabilität: Container können auf mehreren Plattformen (z. B. lokal, Cloud) betrieben werden.
    • Skalierbarkeit: Containerisierte Anwendungen können einfach über Cluster skaliert werden.
    • Effizienz: Effizienter als VMs, da Container sich den Betriebssystem-Kernel teilen.
    • Geschwindigkeit: Schnellere Start- und Herunterfahrzeiten im Vergleich zu VMs.

  • Echte Anwendungen:

    • Von Unternehmen in Bereichen wie Microservices-Architekturen, cloud-nativen Anwendungen und CI/CD-Pipelines übernommen.

3. Wann sollte man Containerisierung einsetzen (oder nicht)?

  • Geeignete Anwendungsfälle:

    • Microservices: Aufteilen großer Anwendungen in unabhängige Dienste.
    • CI/CD-Pipelines: Automatisierte Tests und Deployments in verschiedenen Umgebungen.
    • Entwicklungsumgebungen: Einheitliche Entwicklungs- und Produktionsumgebungen schaffen.

  • Wann Containerisierung weniger sinnvoll ist:

    • Komplexe monolithische Anwendungen: Wenn spezifische Hardware oder Umgebungskonfigurationen notwendig sind.
    • Ressourcenintensive Anwendungen: Anwendungen, die strikte Kontrolle über CPU und RAM benötigen, könnten von Containerisierung beeinträchtigt werden.
    • Altsysteme: Ältere Systeme, die schwer in Container zu migrieren sind.

4. Einführung in Docker

  • Was ist Docker?:

    • Docker ist eine Open-Source-Plattform, die die Bereitstellung, Skalierung und Verwaltung von Anwendungen in Containern automatisiert.

  • Docker-Komponenten:

    • Docker Engine: Kernkomponente zum Ausführen von Containern.
    • Docker Hub: Ein Register für Docker-Images.
    • Docker Compose: Tool zum Definieren und Ausführen von Multi-Container-Anwendungen.

  • Wie Docker die Entwicklung verändert hat:

    • Vereinfachte die Erstellung und Verwaltung von Containern.
    • Bietet einen Standard für Containerisierung.

  • Wichtige Begriffe:

    • Dockerfile:
      • Textdatei mit Anweisungen zur Erstellung des Docker-Images
      • “Rezept” für den Container
    • Image:
      • “Blaupause” eines Containers, der aus Dockerfile gebaut wird
      • Enthält alle notwendigen Dateien und Abhängigkeiten (Betriebssystem, Programmbibliotheken, Anwendungscode, etc.)
      • Grundlage für weitere Containerstarts
    • Volumes: Persistente Speicherung von Daten unabhängig von Containern

5. Wie containerisiert man eine Anwendung mit Docker?

Schritte zur Containerisierung einer einfachen Anwendung:

  1. Schritt 1: Docker installieren

    • Stelle sicher, dass Docker auf deinem Rechner installiert ist.

  2. Schritt 2: Erstellen einer Dockerfile

    • Eine Dockerfile ist eine Textdatei, die Anweisungen für den Bau des Docker-Images enthält.
    • Beispiel für eine Node.js-Anwendung: 
      # Schritt 1: Basis-Image
FROM node:14

# Schritt 2: Arbeitsverzeichnis festlegen
WORKDIR /usr/src/app

# Schritt 3: Anwendungscode kopieren
COPY . .

# Schritt 4: Abhängigkeiten installieren
RUN npm install

# Schritt 5: Anwendung starten
CMD ["node", "app.js"]

# Schritt 6: Port freigeben
EXPOSE 3000

  3. Schritt 3: Docker-Image bauen

    • Befehl: docker build -t my-app .

  4. Schritt 4: Container starten

    • Befehl: docker run -p 3000:3000 my-app

  5. Schritt 5: Volumes einbinden, um Daten persistent zu speichern (optiional)

    • Beispiel-Befehl für eine MongoDB: docker run -v /mein/host/pfad:/data/db --name mongo-container mongo

  6. Schritt 6: In Docker Hub hochladen (optional)

    • Befehl: docker push benutzername/app-name

6. Zusammenfassung & Fazit

  • Wichtige Erkenntnisse:

    • Containerisierung macht Anwendungen portabel, skalierbar und effizient.
    • Docker vereinfacht die Erstellung und Verwaltung von Containern.
    • Nutze Docker, wenn du skalierbare und portable Anwendungen baust, aber beachte auch die Grenzen.

  • Abschließende Bemerkung:

    • Containerisierung ist ein entscheidender Teil der modernen Softwareentwicklung und -bereitstellung, und Docker hat sich als das Standard-Tool dafür etabliert.

7. Quellen

stac client for python:

Grundlagen

import json # Zur Anzeige der Abfrageergebnisse import pystac import requests # Für Interaktion mit APIs

from pystac import Catalog, get_stac_version # Erweiterung von pystac zum Einbinden von bestehenden Catalogs from pystac_client import Client # Erweiterung von pystac u.a. zum suchen in STACs

Einbinden eines STACs

root_catalog = Catalog.from_file('https://raw.githubusercontent.com/stac-utils/pystac/main/docs/example-catalog/catalog.json') root_catalog.describe() # Aufbau des Catalogs

Informationen über den Catalog

Informationen über den Stac Clienten

print(f"ID: {root_catalog.id}") print(f"Title: {root_catalog.title or 'N/A'}") print(f"Description: {root_catalog.description or 'N/A'}")

Informationen über die vorhandenen Collections

collections = list(root_catalog.get_collections()) # get_collections() und weitere Func. im Handout erläutert print(f"Number of collections: {len(collections)}") # Anzahl der vorhandenen Collections print("Collections IDs:") for collection in collections: print(f"- {collection.id}")

Informationen über die vorhandenen Items

items = list(root_catalog.get_all_items()) print(f"Number of items: {len(items)}") for item in items: print(f"- {item.id}")

Abfragen von einzelnen STAC Objekten

item = root_catalog.get_item("LC80140332018166LGN00", recursive=True) # Einzelenes Item, weitere Benutzung im Folgenden

collection = root_catalog.get_collection("ID", recursive=BOOL)

weitere möglich

Abfragen von Metadaten

print(item.geometry) print(item.bbox) print(item.datetime) print(item.collection_id) item.get_collection() # Abfrage, zu welcher Collection das item gehört

Erweiterte Metadaten abfragen (Common Metadata)

print(item.common_metadata.instruments) print(item.common_metadata.platform) print(item.common_metadata.gsd)

Abfrage von Assets

for asset_key in item.assets: #.assets als Func zur Abfrage aller Assets eines Items asset = item.assets[asset_key] print('{}: {} ({})'.format(asset_key, asset.href, asset.media_type)) # asset-key,(..) werden in den String {},(..) eingesetzt

Informationen über ein Asset

asset = item.assets['B3'] print(asset.to_dict()) # Ähnlich zur Abfrage mit .format

Speichern von Daten aus einem STAC

for asset_key in item.assets: asset = item.assets[asset_key] asset_url = asset.href file_name = asset_key + '.' + asset.media_type.split('/')[-1]

# Fragt die Daten von der API ab
response = requests.get(asset_url) # Nutzung der requests-Library

# Speichere die Datei
with open(file_name, 'wb') as f:
    f.write(response.content)

print(f'{file_name} heruntergeladen.')

Weitere Optionen mit der Client-Extension von pystac

STAC einbinden

catalog_url = 'https://planetarycomputer.microsoft.com/api/stac/v1' client = Client.open(catalog_url) # Client interagiert mit API-Endpunkt (URL)

Suche nach Items (Beispiel Sentinel-2)

search = client.search( collections=['sentinel-2-l2a'], bbox=[-47.02148, -17.35063, -42.53906, -12.98314], datetime='2023-01-01/2023-01-31', limit = 10 )

Ein Item aus den Ergebnissen abrufen

items = list(search.items()) print(len(items)) print(items) item = items[5] print(f"Item ID: {item.id}") print(f"Item datetime: {item.datetime}")

Informationen der Items aus den Ergebnissen abrufen

for asset_key, asset in item.assets.items(): print(f"Asset Key: {asset_key}") print(f"Asset URL: {asset.href}") print(f"Asset Media Type: {asset.media_type}")

stac client for R:

Installieren der benötigten Pakete:

install.packages("rstac") install.packages("sf") install.packages("terra") install.packages("tibble") library(terra) library(sf) library(tibble) library(rstac)

Angeben einer URL zu einer Stac API

stac_url <- "https://planetarycomputer.microsoft.com/api/stac/v1"

Aufbau der Verbindung zur API

s_obj <- stac(stac_url) str(s_obj)

Informationen über die stac API:

get_request(s_obj)

alternativ:

s_obj %>% get_request()

Anforderungen und Spezifikationen:

conformance_classes <- s_obj %>% conformance() %>% get_request() conformance_classes

Abfrage des Collections-Endpoint, nicht des top-level Endpoints

collections_query <- s_obj %>% collections()

Liste aller verfügbaren Collections, also der verfügbaren datasets

collections_query %>% get_request()

Suchanfrage an den Catalog stellen:

stac_search( q = s_obj, collections = "usgs-lcmap-conus-v13", datetime = "2021-01-01/2021-12-31", limit = 10 ) %>% get_request()

Beispiel zur Suche nach bestimmter Region (Ashe Couty, North Carolina)

ashe <- read_sf(system.file("shape/nc.shp", package = "sf"))[1, ] plot(st_geometry(ashe))

ashe_bbox <- ashe %>% st_transform(4326) %>% st_bbox() ashe_bbox

stac_query <- stac_search( q = s_obj, collections = "usgs-lcmap-conus-v13", bbox = ashe_bbox, datetime = "2021-01-01/2021-12-31", limit = 10 ) %>% get_request() stac_query

signed_stac_query <- items_sign( stac_query, sign_planetary_computer() # Authentifizierung beim Planetary Computer ) signed_stac_query

Download des Datasets (lcpri: primary land coverage)

output_directory <- "C:/Users/lraeu/OneDrive/Desktop/Geosoftware II/geosoft2-2024/data" assets_download(signed_stac_query, "lcpri", output_dir = output_directory, overwrite = TRUE) output_file <- file.path("C:/Users/lraeu/OneDrive/Desktop/Geosoftware II/geosoft2-2024/data/lcmap/CU/V13/025011/2021/LCMAP_CU_025011_2021_20220721_V13_CCDC/LCMAP_CU_025011_2021_20220629_V13_LCPRI.tif") %>% rast() plot(output_file) rast("C:/Users/lraeu/OneDrive/Desktop/Geosoftware II/geosoft2-2024/data/B1.tiff")

ashe %>% st_transform(st_crs(output_file)) %>% st_geometry() %>% plot(add = TRUE, lwd = 3)

Clone this wiki locally