Service-Authentifizierung

curl -H "X-API-KEY: your-api-key" https://yourservice.dtz.rocks/api/endpoint

curl -H "Authorization: Bearer your-jwt-token" https://yourservice.dtz.rocks/api/endpoint

curl -u apikey:your-api-key https://yourservice.dtz.rocks/api/endpoint

import os
import requests

# Holen Sie das DTZ-Zugriffstoken aus der Umgebung
token = os.environ.get('DTZ_ACCESS_TOKEN')
context_id = os.environ.get('DTZ_CONTEXT_ID')

# Führen Sie eine authentifizierte Anfrage an die DTZ-API aus
headers = {
    'Authorization': f'Bearer {token}',
    'Content-Type': 'application/json'
}

response = requests.get(
    'https://api.dtz.rocks/v1/containers/services',
    headers=headers
)

// Node.js example
const token = process.env.DTZ_ACCESS_TOKEN;
const contextId = process.env.DTZ_CONTEXT_ID;

const response = await fetch('https://api.dtz.rocks/v1/containers/services', {
    headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
    }
});

# Bash example
curl -H "Authorization: Bearer $DTZ_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     https://api.dtz.rocks/v1/containers/services

import jwt
import os
from flask import Flask, request

app = Flask(__name__)

@app.route('/protected')
def protected_endpoint():
    auth_header = request.headers.get('Authorization')
    if not auth_header or not auth_header.startswith('Bearer '):
        return {'error': 'Keine Authentifizierung bereitgestellt'}, 401
    
    token = auth_header.split(' ')[1]
    
    try:
        # Das Token ist bereits von DTZ verifiziert, daher können Sie 
        # Ansprüche ohne Signaturprüfung extrahieren.
        payload = jwt.decode(token, options={"verify_signature": False})
        
        user_id = payload.get('sub')  # Identity ID
        context_id = payload.get('scope')  # Context ID
        roles = payload.get('roles', [])  # Benutzerrollen
        
        return {
            'user_id': user_id,
            'context_id': context_id,
            'roles': roles,
            'message': 'Zugriff gewährt'
        }
    except jwt.InvalidTokenError:
        return {'error': 'Ungültiges Token'}, 401

// Express.js example
const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();

app.get('/protected', (req, res) => {
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: 'Keine Authentifizierung bereitgestellt' });
    }
    
    const token = authHeader.split(' ')[1];
    
    try {
        // Das Token ist bereits von DTZ verifiziert.
        const payload = jwt.decode(token);
        
        const userId = payload.sub;      // Identity ID
        const contextId = payload.scope; // Context ID
        const roles = payload.roles || [];    // Benutzerrollen
        
        res.json({
            user_id: userId,
            context_id: contextId,
            roles: roles,
            message: 'Zugriff gewährt'
        });
    } catch (error) {
        res.status(401).json({ error: 'Ungültiges Token' });
    }
});

def check_role(token, required_role_pattern):
    payload = jwt.decode(token, options={"verify_signature": False})
    roles = payload.get('roles', [])
    context_id = payload.get('scope')
    
    required_role = required_role_pattern.replace('{context_id}', context_id)
    return required_role in roles

# Beispiel:
if check_role(token, 'https://dtz.rocks/containers/admin/{context_id}'):
    # Benutzer hat Container-Admin-Berechtigungen
    pass

import os
import jwt
import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

DTZ_TOKEN = os.environ.get('DTZ_ACCESS_TOKEN')
DTZ_CONTEXT_ID = os.environ.get('DTZ_CONTEXT_ID')

def get_user_from_token(token):
    """Extrahiert Benutzerinformationen aus einem DTZ-JWT-Token."""
    try:
        payload = jwt.decode(token, options={"verify_signature": False})
        return {
            'user_id': payload.get('sub'),
            'context_id': payload.get('scope'),
            'roles': payload.get('roles', [])
        }
    except jwt.InvalidTokenError:
        return None

def require_auth(f):
    """Ein Decorator, der Authentifizierung erfordert."""
    def decorated(*args, **kwargs):
        auth_header = request.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Bearer '):
            return jsonify({'error': 'Authentifizierung erforderlich'}), 401
        
        token = auth_header.split(' ')[1]
        user = get_user_from_token(token)
        
        if not user:
            return jsonify({'error': 'Ungültiges Token'}), 401
        
        request.user = user
        return f(*args, **kwargs)
    
    decorated.__name__ = f.__name__
    return decorated

@app.route('/health')
def health():
    """Ein öffentlicher Health-Check-Endpunkt."""
    return jsonify({'status': 'healthy'})

@app.route('/profile')
@require_auth
def profile():
    """Ein geschützter Endpunkt, der das Profil des Benutzers zurückgibt."""
    return jsonify({
        'user_id': request.user['user_id'],
        'context_id': request.user['context_id'],
        'roles': request.user['roles']
    })

@app.route('/admin/users')
@require_auth
def admin_users():
    """Ein nur für Admins zugänglicher Endpunkt."""
    required_role = f'https://dtz.rocks/context/admin/{DTZ_CONTEXT_ID}'
    
    if required_role not in request.user['roles']:
        return jsonify({'error': 'Admin-Zugriff erforderlich'}), 403
    
    # Führen Sie eine authentifizierte Anfrage an die DTZ-API aus
    headers = {'Authorization': f'Bearer {DTZ_TOKEN}'}
    response = requests.get(
        'https://identity.dtz.rocks/api/2021-02-21/users',
        headers=headers
    )
    
    return jsonify(response.json())

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 80))
    app.run(host='0.0.0.0', port=port)

# Test mit einem API-Schlüssel
curl -H "X-API-KEY: your-api-key" https://yourservice.dtz.rocks/profile

# Test mit einem Bearer-Token  
curl -H "Authorization: Bearer your-jwt-token" https://yourservice.dtz.rocks/profile

# Test unauthentifiziert (sollte 401 zurückgeben)
curl https://yourservice.dtz.rocks/profile