# Stoppen Sie eine laufende Sitzung
<a name="runtime-stop-session"></a>

Mit diesem `StopRuntimeSession` Vorgang können Sie aktive AgentCore Agent-Runtime-Sitzungen sofort beenden, um die Ressourcen ordnungsgemäß zu bereinigen und den Sitzungslebenszyklus ordnungsgemäß zu verwalten.

Wenn dieser Vorgang aufgerufen wird, beendet er sofort die angegebene Sitzung und beendet alle laufenden Streaming-Antworten. Dadurch können Systemressourcen ordnungsgemäß freigegeben werden und die Anhäufung verwaister Sitzungen wird verhindert.

Verwenden Sie `StopRuntimeSession` in diesen Szenarien:
+  **User-initiated Ende**: Wenn Benutzer ihre Konversation explizit beenden
+  **Herunterfahren der Anwendung**: Proaktive Bereinigung vor dem Beenden der Anwendung
+  **Fehlerbehandlung**: Erzwingt die Beendigung von Sitzungen, die nicht reagieren oder angehalten wurden
+  **Kontingentverwaltung**: Halten Sie sich an die Sitzungslimits, indem Sie ungenutzte Sitzungen schließen
+  **Behandlung von Timeouts**: Bereinigen Sie Sitzungen, die die erwartete Dauer überschreiten

## Voraussetzungen
<a name="prerequisites"></a>

Um es zu verwenden [StopRuntimeSession](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_StopRuntimeSession.html), benötigen Sie:
+  `bedrock-agentcore:StopRuntimeSession`-IAM-Berechtigung
+ Ein gültiger AgentCore Runtime-ARN für Agenten
+ Die ID einer aktiven Sitzung, die beendet werden soll

**Example**  

1. Sie können das AWS SDK verwenden, um AgentCore Runtime-Sitzungen programmgesteuert zu beenden.

   Python-Beispiel, das boto3 verwendet, um eine AgentCore Runtime-Sitzung zu beenden.

   ```
   import boto3
   
   # Initialize the AgentCore client
   client = boto3.client('bedrock-agentcore', region_name='us-west-2')
   
   try:
       # Stop the runtime session
       response = client.stop_runtime_session(
           agentRuntimeArn='arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent',
           runtimeSessionId='your-session-id',
           qualifier='DEFAULT'  # Optional: endpoint name
       )
   
       print(f"Session terminated successfully")
       print(f"Request ID: {response['ResponseMetadata']['RequestId']}")
   
   except client.exceptions.ResourceNotFoundException:
       print("Session not found or already terminated")
   except client.exceptions.AccessDeniedException:
       print("Insufficient permissions to stop session")
   except Exception as e:
       print(f"Error stopping session: {str(e)}")
   ```

1. Stellen Sie für Anwendungen, die die OAuth-Authentifizierung verwenden, direkte HTTPS-Anfragen:

   ```
   import requests
   import urllib.parse
   
   def stop_session_with_oauth(agent_arn, session_id, bearer_token, qualifier="DEFAULT"):
       # URL encode the agent ARN
       encoded_arn = agent_arn.replace(':', '%3A').replace('/', '%2F')
   
       # Construct the endpoint URL
       url = f"https://bedrock-agentcore.us-west-2.amazonaws.com/runtimes/{encoded_arn}/stopruntimesession?qualifier={qualifier}"
   
       headers = {
           "Authorization": f"Bearer {bearer_token}",
           "Content-Type": "application/json",
           "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id": session_id
       }
   
       try:
           response = requests.post(url, headers=headers)
           response.raise_for_status()
   
           print(f"Session {session_id} terminated successfully")
           return response.json()
   
       except requests.exceptions.HTTPError as e:
           if e.response.status_code == 404:
               print("Session not found or already terminated")
           elif e.response.status_code == 403:
               print("Insufficient permissions or invalid token")
           else:
               print(f"HTTP error: {e.response.status_code}")
           raise
       except requests.exceptions.RequestException as e:
           print(f"Request failed: {str(e)}")
           raise
   
   # Usage
   stop_session_with_oauth(
       agent_arn="arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent",
       session_id="your-session-id",
       bearer_token="your-oauth-token"
   )
   ```

## Reaktionsformat
<a name="response-format"></a>

Erwartetes Antwortformat für erfolgreiche `StopRuntimeSession` Operationen.

```
{
    "ResponseMetadata": {
        "RequestId": "12345678-1234-1234-1234-123456789012",
        "HTTPStatusCode": 200
    }
}
```

## Fehlerbehandlung
<a name="error-handling"></a>

Häufige Fehlerantworten:


| Statuscode | Fehler | Description | 
| --- | --- | --- | 
| 404 | ResourceNotFoundException | Sitzung wurde nicht gefunden oder wurde bereits beendet | 
| 403 | AccessDeniedException | Unzureichende Berechtigungen | 
| 400 | ValidationException | Ungültige Parameter | 
| 500 | InternalServerException | Servicefehler | 

## Bewährte Methoden
<a name="best-practices"></a>

### Verwaltung des Sitzungslebenszyklus
<a name="session-lifecycle-management"></a>

```
class SessionManager:
    def __init__(self, client, agent_arn):
        self.client = client
        self.agent_arn = agent_arn
        self.active_sessions = set()

    def invoke_agent(self, session_id, payload):
        """Invoke agent and track session"""
        try:
            response = self.client.invoke_agent_runtime(
                agentRuntimeArn=self.agent_arn,
                runtimeSessionId=session_id,
                payload=payload
            )
            self.active_sessions.add(session_id)
            return response
        except Exception as e:
            print(f"Failed to invoke agent: {e}")
            raise

    def stop_session(self, session_id):
        """Stop session and remove from tracking"""
        try:
            self.client.stop_runtime_session(
                agentRuntimeArn=self.agent_arn,
                runtimeSessionId=session_id,
                qualifier=endpoint_name
            )
            self.active_sessions.discard(session_id)
            print(f"Session {session_id} stopped")
        except Exception as e:
            print(f"Failed to stop session {session_id}: {e}")

    def cleanup_all_sessions(self):
        """Stop all tracked sessions"""
        for session_id in list(self.active_sessions):
            self.stop_session(session_id)
```

### Empfehlungen
<a name="recommendations"></a>
+  **Behandeln Sie immer Ausnahmen**, wenn Sie Sitzungen beenden
+  **Verfolgen Sie aktive Sitzungen** in Ihrer Anwendung zur Bereinigung
+  **Legen Sie Timeouts** für Stopp-Anfragen fest, um ein Hängenbleiben zu vermeiden
+  **Protokollieren Sie Sitzungsabbrüche** zum Debuggen und Überwachen
+  **Verwenden Sie Sitzungsmanager** für komplexe Anwendungen mit mehreren Sitzungen