Kurzlebige Zugriffstoken abrufen

Zuletzt aktualisiert am 30. Okt. 2026

Voraussetzungen

Sie haben einen Service Account: Einen neuen Service Account erstellen
Sie haben einen Service Account Key erstellt: Einen neuen Service Account Key erstellen

Vorgehensweise

Verwenden Sie diesen Befehl, wenn das Schlüsselpaar von STACKIT generiert wurde:

stackit auth activate-service-account --service-account-key-path service-account.json --only-print-access-token

Verwenden Sie diesen Befehl, wenn Sie den privaten Schlüssel selbst erstellt haben:

stackit auth activate-service-account --service-account-key-path service-account.json --private-key-path key.pem --only-print-access-token

Manuelle Implementierung

Um manuell ein kurzlebiges Zugriffstoken abzurufen, müssen Sie zuerst ein JWT erstellen und signieren. Die folgenden Felder werden benötigt.

kid: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
alg: Ihr Signaturalgorithmus - wir empfehlen „RS512“.
typ: „JWT“

Body:

iss: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
sub: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
aud: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
jti: Befüllen Sie dieses Feld, indem Sie eine uuidv4-Zeichenkette generieren.
iat: Befüllen Sie dieses Feld mit der aktuellen Zeit im Epoch-Time-Format in Ihrer lokalen Zeit.
exp: Befüllen Sie dieses Feld mit der aktuellen Zeit (lokale Zeit) + 600 Sekunden im Epoch-Time-Format.

Das folgende Bash-Skript setzt all diese Aufgaben um. Nutzen Sie es als Referenz für Ihre manuellen Implementierungen.

Lesen Sie die Dokumentation Request short lived API token im API Explorer.

Verwendung

Verwenden Sie das folgende Bash-Skript, um ein Zugriffstoken unter Linux oder macOS abzurufen.

Voraussetzungen

Bash 4.0 oder neuer
jq, openssl, curl und uuidgen installiert
Ein STACKIT Service Account mit einer gültigen JSON-Konfigurationsdatei

Schritte zum Abrufen eines Zugriffstokens mit dem Bash-Skript:

Laden Sie Ihre Service Account-Konfiguration aus dem STACKIT Portal herunter und speichern Sie sie als service-account.json.
Kopieren Sie das Bash-Skript get-stackit-access-token.sh.
Machen Sie das Skript ausführbar:
Terminal-Fenster
```
chmod +x get-stackit-access-token.sh
```
Führen Sie das Skript aus:
Terminal-Fenster
```
./get-stackit-access-token.sh
```
Alternativ können Sie einen benutzerdefinierten Pfad zur Konfigurationsdatei angeben:
Terminal-Fenster
```
./get-stackit-access-token.sh /pfad/zu/service-account.json
```

Das Skript gibt das Zugriffstoken aus. Um es für API-Anfragen zu verwenden:

ACCESS_TOKEN=$(./get-stackit-access-token.sh | tail -1)

curl -H "Authorization: Bearer $ACCESS_TOKEN" \
     "https://api.stackit.cloud/v1/..."

Bash-Skript

#!/bin/bash

set -euo pipefail

CONFIG="service-account.json"
TOKEN_URL="https://accounts.stackit.cloud/oauth/v2/token"

# --- Konfiguration aus JSON-Datei lesen ---
ISS=$(jq -r '.credentials.iss' "$CONFIG")
SUB=$(jq -r '.credentials.sub' "$CONFIG")
AUD=$(jq -r '.credentials.aud' "$CONFIG")
KID=$(jq -r '.credentials.kid' "$CONFIG")
PRIVATE_KEY_RAW=$(jq -r '.credentials.privateKey' "$CONFIG")

# --- Privaten Schlüssel in Datei schreiben ---
PRIVATE_KEY_FILE=$(mktemp)
echo "$PRIVATE_KEY_RAW" | sed 's/\\n/\n/g' > "$PRIVATE_KEY_FILE"

# --- Zeitstempel für JWT ---
NOW=$(date +%s)
EXP=$((NOW + 600))  # Token-Gültigkeit auf zehn Minuten festlegen
JTI=$(uuidgen) # Optional in der Spezifikation, aber für STACKIT erforderlich

# --- JWT-Header & Payload ---
HEADER=$(jq -nc --arg kid "$KID" '{alg:"RS512", typ:"JWT", kid:$kid}')
PAYLOAD=$(jq -nc \
  --arg iss "$ISS" \
  --arg sub "$SUB" \
  --arg aud "$AUD" \
  --arg jti "$JTI" \
  --argjson iat "$NOW" \
  --argjson exp "$EXP" \
  '{iss:$iss, sub:$sub, aud:$aud, iat:$iat, exp:$exp, jti:$jti}')

# --- Base64URL-Kodierungsfunktion ---
b64enc() {
  openssl base64 -e -A | tr '+/' '-_' | tr -d '='
}

# --- JWT erstellen und signieren ---
HEADER_B64=$(echo -n "$HEADER" | b64enc)
PAYLOAD_B64=$(echo -n "$PAYLOAD" | b64enc)
DATA="${HEADER_B64}.${PAYLOAD_B64}"

SIGNATURE=$(echo -n "$DATA" | openssl dgst -sha512 -sign "$PRIVATE_KEY_FILE" | b64enc)
JWT="${DATA}.${SIGNATURE}"

echo "$JWT"

# --- Zugriffstoken anfordern ---
echo "🔐 Anfrage an $TOKEN_URL ..."
RESPONSE=$(curl --fail -sS -X POST "$TOKEN_URL" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer" \
  -d "assertion=$JWT") || {
    echo "❌ Fehler beim Abrufen des Tokens"
    exit 1
}

# --- Zugriffstoken extrahieren ---
ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r '.access_token')

if [[ "$ACCESS_TOKEN" == "null" || -z "$ACCESS_TOKEN" ]]; then
  echo "❌ Kein Zugriffstoken erhalten!"
  echo "$RESPONSE"
  exit 1
fi

# --- Ausgabe ---
echo "✅ Zugriffstoken erhalten:"
echo "$ACCESS_TOKEN"

# --- Bereinigung ---
rm -f "$PRIVATE_KEY_FILE"

Manuelle Implementierung

Um manuell ein kurzlebiges Zugriffstoken abzurufen, müssen Sie zuerst ein JWT erstellen und signieren. Die folgenden Felder werden benötigt.

Header:

kid: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
alg: Ihr Signaturalgorithmus - wir empfehlen „RS512“.
typ: „JWT“

Payload:

iss: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
sub: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
aud: Befüllen Sie dieses Feld, indem Sie den entsprechenden Schlüssel aus service-account.json extrahieren.
jti: Befüllen Sie dieses Feld, indem Sie eine uuidv4-Zeichenkette generieren.
iat: Befüllen Sie dieses Feld mit der aktuellen Zeit im Epoch-Time-Format in Ihrer lokalen Zeit.
exp: Befüllen Sie dieses Feld mit der aktuellen Zeit (lokale Zeit) + 600 Sekunden im Epoch-Time-Format.

Das folgende PowerShell-Skript setzt all diese Aufgaben um. Nutzen Sie es als Referenz für Ihre manuellen Implementierungen.

Lesen Sie die Dokumentation Request short lived API token im API Explorer.

Verwendung

Verwenden Sie das folgende PowerShell-Skript, um ein Zugriffstoken unter Windows abzurufen.

Voraussetzungen

PowerShell 5.1 oder neuer (in Windows 10/11 enthalten) oder PowerShell Core
Ein STACKIT Service Account mit einer gültigen JSON-Konfigurationsdatei

Schritte zum Abrufen eines Zugriffstokens mit dem PowerShell-Skript:

Laden Sie Ihre Service Account-Konfiguration aus dem STACKIT Portal herunter und speichern Sie sie als service-account.json.
Kopieren Sie das Skript Get-StackitAccessToken.ps1.
Öffnen Sie PowerShell und navigieren Sie in das Verzeichnis, das das Skript enthält.
Führen Sie das Skript aus:
Terminal-Fenster
```
.\Get-StackitAccessToken.ps1
```
Alternativ können Sie einen benutzerdefinierten Pfad zur Konfigurationsdatei angeben:
Terminal-Fenster
```
.\Get-StackitAccessToken.ps1 -ConfigPath "C:\pfad\zu\service-account.json"
```

Das Skript gibt das Zugriffstoken aus. Um es für API-Anfragen zu verwenden:

$AccessToken = .\Get-StackitAccessToken.ps1 | Select-Object -Last 1

$Headers = @{ "Authorization" = "Bearer $AccessToken" }
Invoke-RestMethod -Uri "https://api.stackit.cloud/v1/..." -Headers $Headers

PowerShell-Skript

<#
.SYNOPSIS
    Ruft ein STACKIT-Zugriffstoken unter Verwendung eines Service Accounts ab.

.DESCRIPTION
    Dieses Skript authentifiziert sich beim STACKIT Identity Provider unter Verwendung
    einer Service Account JSON-Konfigurationsdatei und gibt ein Zugriffstoken zurück.
    Es erstellt ein signiertes JWT (RS512) und tauscht dieses gegen ein Zugriffstoken ein.

.PARAMETER ConfigPath
    Pfad zur Service Account JSON-Konfigurationsdatei.
    Standard: service-account.json

.EXAMPLE
    .\Get-StackitAccessToken.ps1

.EXAMPLE
    .\Get-StackitAccessToken.ps1 -ConfigPath "C:\pfad\zu\service-account.json"

.NOTES
    Plattformübergreifend kompatibles Skript.

    Windows (PowerShell 5.1+):
- Verwendet CNG-RSA-Signierung (Cryptography Next Generation)
- Erfordert .NET Framework 4.6+

    Linux/macOS (PowerShell Core/7+):
- Verwendet ImportPkcs8PrivateKey oder ImportFromPem (.NET 5+)

    Getestet auf:
- Windows PowerShell 5.1
- PowerShell Core 7.x unter Windows/Linux/macOS
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory = $false)]
    [string]$ConfigPath = "service-account.json"
)

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

# Versionsinformationen für das Debugging anzeigen
$PSVersion = $PSVersionTable.PSVersion
$IsPwshCore = $PSVersionTable.PSVersion.Major -ge 6 -or $PSVersionTable.PSEdition -eq "Core"
Write-Host "PowerShell: v$PSVersion $(if ($IsPwshCore) { '(Core)' } else { '(Windows)' })" -ForegroundColor Gray

$TokenUrl = "https://accounts.stackit.cloud/oauth/v2/token"

function ConvertTo-Base64Url {
    param([byte[]]$Bytes)
    return [Convert]::ToBase64String($Bytes).TrimEnd('=').Replace('+', '-').Replace('/', '_')
}

function ConvertTo-Base64UrlFromString {
    param([string]$Text)
    return ConvertTo-Base64Url -Bytes ([System.Text.Encoding]::UTF8.GetBytes($Text))
}

function Invoke-RsaSigning {
    param(
        [string]$PrivateKeyPem,
        [byte[]]$DataToSign
    )

    # Base64-Inhalt aus PEM extrahieren
    $KeyContent = $PrivateKeyPem -replace "-----BEGIN PRIVATE KEY-----", "" `
                                  -replace "-----END PRIVATE KEY-----", "" `
                                  -replace "-----BEGIN RSA PRIVATE KEY-----", "" `
                                  -replace "-----END RSA PRIVATE KEY-----", "" `
                                  -replace "\s", ""

    $KeyBytes = [Convert]::FromBase64String($KeyContent)

    # Methode 1: CNG-Ansatz versuchen (Windows PowerShell 5.1+)
    if ([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform([System.Runtime.InteropServices.OSPlatform]::Windows)) {
        try {
            Write-Host "Versuche CNG-RSA-Import..." -ForegroundColor Gray
            $CertFactory = [System.Security.Cryptography.CngKey]::Import($KeyBytes,
                [System.Security.Cryptography.CngKeyBlobFormat]::Pkcs8PrivateBlob)
            $RsaCng = New-Object System.Security.Cryptography.RSACng($CertFactory)

            $SignatureBytes = $RsaCng.SignData($DataToSign,
                [System.Security.Cryptography.HashAlgorithmName]::SHA512,
                [System.Security.Cryptography.RSASignaturePadding]::Pkcs1)
            Write-Host "JWT erfolgreich signiert (CNG-Methode)" -ForegroundColor Green
            return $SignatureBytes
        }
        catch {
            Write-Host "CNG-Methode fehlgeschlagen: $($_.Exception.Message)" -ForegroundColor Yellow
        }
    }

    # Methode 2: ImportPkcs8PrivateKey versuchen (plattformübergreifend, verfügbar in .NET 5+)
    try {
        Write-Host "Versuche ImportPkcs8PrivateKey-Methode..." -ForegroundColor Gray
        $Rsa = [System.Security.Cryptography.RSA]::Create()
        $Rsa.ImportPkcs8PrivateKey($KeyBytes, [ref]$null)

        $SignatureBytes = $Rsa.SignData($DataToSign,
            [System.Security.Cryptography.HashAlgorithmName]::SHA512,
            [System.Security.Cryptography.RSASignaturePadding]::Pkcs1)
        Write-Host "JWT erfolgreich signiert (ImportPkcs8PrivateKey-Methode)" -ForegroundColor Green
        return $SignatureBytes
    }
    catch {
        Write-Host "ImportPkcs8PrivateKey-Methode nicht verfügbar: $($_.Exception.Message)" -ForegroundColor Yellow
    }

    # Methode 3: ImportFromPem versuchen (PowerShell 7.2+, .NET 6+)
    try {
        Write-Host "Versuche ImportFromPem-Methode..." -ForegroundColor Gray
        $Rsa = [System.Security.Cryptography.RSA]::Create()
        $Rsa = [System.Security.Cryptography.RSA]::ImportFromPem($PrivateKeyPem)

        $SignatureBytes = $Rsa.SignData($DataToSign,
            [System.Security.Cryptography.HashAlgorithmName]::SHA512,
            [System.Security.Cryptography.RSASignaturePadding]::Pkcs1)
        Write-Host "JWT erfolgreich signiert (ImportFromPem-Methode)" -ForegroundColor Green
        return $SignatureBytes
    }
    catch {
        Write-Host "ImportFromPem-Methode nicht verfügbar: $($_.Exception.Message)" -ForegroundColor Yellow
    }

    Write-Error @"
Der private RSA-Schlüssel konnte nicht importiert werden. Dieses Skript erfordert:
PowerShell 5.1+ unter Windows (CNG-Unterstützung), ODER
PowerShell Core/7+ (.NET 5+) mit ImportPkcs8PrivateKey oder ImportFromPem

Aktuell: PowerShell v$($PSVersionTable.PSVersion) unter $([System.Runtime.InteropServices.RuntimeInformation]::OSDescription)
"@
    exit 1
}

if (-not (Test-Path -Path $ConfigPath)) {
    Write-Error "Konfigurationsdatei nicht gefunden: $ConfigPath"
    exit 1
}

# Für plattformübergreifende Kompatibilität in absoluten Pfad auflösen
$ConfigPath = (Resolve-Path -Path $ConfigPath).ProviderPath

Write-Host "Konfiguration wird gelesen..." -ForegroundColor Cyan
$Config = Get-Content -Path $ConfigPath -Raw | ConvertFrom-Json
$Credentials = $Config.credentials

$Iss = $Credentials.iss
$Sub = $Credentials.sub
$Aud = $Credentials.aud
$Kid = $Credentials.kid
$PrivateKeyPem = $Credentials.privateKey -replace '\\n', "`n"

$Now = [DateTimeOffset]::UtcNow.ToUnixTimeSeconds()
$Exp = $Now + 600
$Jti = [Guid]::NewGuid().ToString()

$Header = @{ alg = "RS512"; typ = "JWT"; kid = $Kid } | ConvertTo-Json -Compress
$Payload = @{ iss = $Iss; sub = $Sub; aud = $Aud; iat = $Now; exp = $Exp; jti = $Jti } | ConvertTo-Json -Compress

$HeaderB64 = ConvertTo-Base64UrlFromString -Text $Header
$PayloadB64 = ConvertTo-Base64UrlFromString -Text $Payload
$DataToSign = "$HeaderB64.$PayloadB64"

Write-Host "JWT wird signiert..." -ForegroundColor Cyan

try {
    $DataBytes = [System.Text.Encoding]::UTF8.GetBytes($DataToSign)
    $SignatureBytes = Invoke-RsaSigning -PrivateKeyPem $PrivateKeyPem -DataToSign $DataBytes
    $SignatureB64 = ConvertTo-Base64Url -Bytes $SignatureBytes
}
catch {
    Write-Error "JWT-Signierung fehlgeschlagen: $($_.Exception.Message)"
    exit 1
}

$Jwt = "$DataToSign.$SignatureB64"
Write-Host "Token wird angefordert..." -ForegroundColor Cyan

$Body = @{
    grant_type = "urn:ietf:params:oauth:grant-type:jwt-bearer"
    assertion  = $Jwt
}

try {
    $Response = Invoke-RestMethod -Uri $TokenUrl -Method Post -ContentType "application/x-www-form-urlencoded" -Body $Body
    Write-Host "Erfolg!" -ForegroundColor Green
    $Response.access_token
}
catch {
    Write-Error "Fehler in der Anfrage: $($_.Exception.Message)"
}