# Browsersitzungen verwalten
## Eine Browsersitzung starten
Nachdem Sie einen Browser erstellt haben, können Sie eine Sitzung starten, um mit Webanwendungen zu interagieren.
**Example**
1. Verwenden Sie den `start-browser-session` folgenden Befehl, um eine Browsersitzung mit der AWS CLI zu starten:
```
aws bedrock-agentcore start-browser-session \
--region \
--browser-identifier "my-browser" \
--name "my-browser-session" \
--session-timeout-seconds 900 \
--view-port width=1456,height=819
```
1. Verwenden Sie die folgende Methode, um eine Browsersitzung mit dem AWS SDK for Python (Boto3) zu starten: `start_browser_session`
**Anforderungssyntax**
Im Folgenden wird die Anforderungssyntax gezeigt:
```
response = dp_client.start_browser_session(
browserIdentifier="aws.browser.v1",
name="browser-session-1",
sessionTimeoutSeconds=3600,
viewPort={
'height': 819,
'width': 1456
}
)
```
1. Um eine Browsersitzung mit der BrowserClient Klasse für mehr Kontrolle über den Sitzungslebenszyklus zu starten:
```
from bedrock_agentcore.tools.browser_client import BrowserClient
# Create a browser client
client = BrowserClient(region="us-west-2")
# Start a browser session
client.start()
print(f"Session ID: {client.session_id}")
try:
# Generate WebSocket URL and headers
url, headers = client.generate_ws_headers()
# Perform browser operations with your preferred automation tool
finally:
# Always close the session when done
client.stop()
```
1. Verwenden Sie den folgenden Aufruf, um mithilfe der API eine neue Browsersitzung zu erstellen:
```
# Using awscurl
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/start" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"name": "browser-session-abc12345",
"description": "browser sandbox session",
"sessionTimeoutSeconds": 300,
"viewPort": {
"height": 819,
"width": 1456
}
}'
```
## Browsersitzung abrufen
Sie können Informationen zu einer von Ihnen erstellten Browsersitzung abrufen.
**Example**
1. Verwenden Sie den `get-browser-session` folgenden Befehl, um Informationen zu einer Browsersitzung mithilfe der AWS CLI abzurufen:
```
aws bedrock-agentcore get-browser-session \
--region \
--browser-identifier "aws.browser.v1" \
--session-id ""
```
1. Verwenden Sie die Methode, um Informationen über eine Browsersitzung mit dem AWS SDK for Python (Boto3) `get_browser_session` abzurufen:
**Anforderungssyntax**
Im Folgenden wird die Anforderungssyntax gezeigt:
```
response = dp_client.get_browser_session(
browserIdentifier="aws.browser.v1",
sessionId=""
)
```
1. Verwenden Sie den folgenden Aufruf, um Informationen über eine Browsersitzung mithilfe der API abzurufen:
```
# Using awscurl
awscurl -X GET \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/get?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region
{
"browserIdentifier": "aws.browser.v1",
"createdAt": "2025-07-14T22:16:40.713152248Z",
"lastUpdatedAt": "2025-07-14T22:16:40.713152248Z",
"name": "testBrowserSession1752531400",
"sessionId": "",
"sessionReplayArtifact": null,
"sessionTimeoutSeconds": 900,
"status": "TERMINATED",
"streams": {
"automationStream": {
"streamEndpoint": "wss://bedrock-agentcore..amazonaws.com/browser-streams/aws.browser.v1/sessions//automation",
"streamStatus": "ENABLED"
},
"liveViewStream": {
"streamEndpoint": "https://bedrock-agentcore..amazonaws.com/browser-streams/aws.browser.v1/sessions//live-view"
}
},
"viewPort": {
"height": 819,
"width": 1456
}
}
```
## Interaktion mit einer Browsersitzung
Sobald Sie eine Browsersitzung gestartet haben, können Sie über die WebSocket API mit ihr interagieren. Sie können die InvokeBrowser API auch zur direkten Steuerung auf Betriebssystemebene verwenden, einschließlich Mausklicks, Tastatureingaben und Screenshots im Vollbildmodus. Weitere Informationen finden Sie unter Aktion mit dem [Browserbetriebssystem](browser-invoke.md).
**Example**
1. ====== Um mit einer Browsersitzung über die Konsole zu interagieren
1. Navigieren Sie zu Ihrer aktiven Browsersitzung.
1. Verwenden Sie die Browseroberfläche, um zu Websites zu navigieren, mit Webelementen zu interagieren und andere Browseraktionen auszuführen.
1. Über die Live-View-Funktion können Sie die Browseraktivitäten in Echtzeit verfolgen.
1. Verwenden Sie die WebSocket-based Streaming-API mit dem folgenden URL-Format, um programmgesteuert mit einer Browsersitzung zu interagieren:
```
https://bedrock-agentcore..amazonaws.com/browser-streams/{browser_id}/sessions/{session_id}/automation
```
Sie können Bibliotheken wie Playwright verwenden, um eine Verbindung mit dem Browser herzustellen WebSocket und ihn zu steuern. Ein Beispiel:
```
from playwright.sync_api import sync_playwright, Playwright, BrowserType
import os
import base64
from bedrock_agentcore.tools.browser_client import browser_session
def main(playwright: Playwright):
# Keep browser session alive during usage
with browser_session('us-west-2') as client:
# Generate CDP endpoint and headers
ws_url, headers = client.generate_ws_headers()
# Connect to browser using headers
chromium: BrowserType = playwright.chromium
browser = chromium.connect_over_cdp(ws_url, headers=headers)
# Use the first available context or create one
context = browser.contexts[0] if browser.contexts else browser.new_context()
page = context.pages[0] if context.pages else context.new_page()
page.goto("https://amazon.com/")
print("Navigated to Amazon")
# Create CDP session for screenshot
cdp_client = context.new_cdp_session(page)
screenshot_data = cdp_client.send("Page.captureScreenshot", {
"format": "jpeg",
"quality": 80,
"captureBeyondViewport": True
})
# Decode and save screenshot
image_data = base64.b64decode(screenshot_data['data'])
with open("screenshot.jpeg", "wb") as f:
f.write(image_data)
print("✅ Screenshot saved as screenshot.jpeg")
page.close()
browser.close()
with sync_playwright() as p:
main(p)
```
Der folgende Beispielcode zeigt, wie Sie mithilfe der WebSocket-based Streaming-API eine Live-Ansicht ausführen können.
```
https://bedrock-agentcore..amazonaws.com/browser-streams/{browser_id}/sessions/{session_id}/live-view
```
Unten ist der Code.
```
import time
from rich.console import Console
from bedrock_agentcore.tools.browser_client import browser_session
from browser_viewer import BrowserViewerServer
console = Console()
def main():
try:
# Step 1: Create browser session
with browser_session('us-west-2') as client:
print("\r ✅ Browser ready! ")
ws_url, headers = client.generate_ws_headers()
# Step 2: Start viewer server
console.print("\n[cyan]Step 3: Starting viewer server...[/cyan]")
viewer = BrowserViewerServer(client, port=8005)
viewer_url = viewer.start(open_browser=True)
# Keep running
while True:
time.sleep(1)
except KeyboardInterrupt:
console.print("\n\n[yellow]Shutting down...[/yellow]")
if 'client' in locals():
client.stop()
console.print("✅ Browser session terminated")
except Exception as e:
console.print(f"\n[red]Error: {e}[/red]")
import traceback
traceback.print_exc()
if __name__ == "__main__":
main()
```
## Browsersitzungen auflisten
Sie können alle aktiven Browsersitzungen auflisten, um Ihre Ressourcen zu überwachen und zu verwalten. Dies ist nützlich, um aktive Sitzungen zu verfolgen, Sitzungen mit langer Laufzeit zu identifizieren oder Sitzungen zu finden, die beendet werden müssen.
**Example**
1. Verwenden Sie den `list-browser-sessions` folgenden Befehl, um Browsersitzungen mit der AWS CLI aufzulisten:
```
aws bedrock-agentcore list-browser-sessions \
--region \
--browser-id "" \
--max-results 10
```
Sie können Sitzungen auch nach Status filtern:
```
aws bedrock-agentcore list-browser-sessions \
--region \
--browser-id "" \
--status "READY"
```
1. Verwenden Sie die folgende Methode, um Browsersitzungen aufzulisten, die das AWS SDK for Python (Boto3) verwenden: `list_browser_sessions`
**Anforderungssyntax**
Im Folgenden wird die Anforderungssyntax gezeigt:
```
response = dp_client.list_browser_sessions(
browserIdentifier="aws.browser.v1"
)
```
Sie können Sitzungen auch nach Status filtern:
```
# List only active sessions
filtered_response = dp_client.list_browser_sessions(
browserIdentifier="aws.browser.v1",
status="READY"
)
# Print filtered session information
for session in filtered_response['items']:
print(f"Ready Session ID: {session['sessionId']}")
print(f"Name: {session['name']}")
print("---")
```
1. Verwenden Sie den folgenden Aufruf, um Browsersitzungen aufzulisten, die die API verwenden:
```
# Using awscurl
awscurl -X POST \
"https://bedrock-agentcore..amazonaws.com/browsers//sessions/list" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"maxResults": 10
}'
```
Sie können Sitzungen auch nach Status filtern:
```
# Using awscurl
awscurl -X POST \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/list" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"maxResults": 10,
"status": "READY"
}'
```
## Eine Browsersitzung beenden
Wenn Sie eine Browsersitzung nicht mehr verwenden, sollten Sie sie beenden, um Ressourcen freizugeben und unnötige Kosten zu vermeiden.
**Example**
1. Verwenden Sie den `stop-browser-session` folgenden Befehl, um eine Browsersitzung mit der AWS CLI zu beenden:
```
aws bedrock-agentcore stop-browser-session \
--region \
--browser-id "" \
--session-id ""
```
1. Verwenden Sie die folgende Methode, um eine Browsersitzung mit dem AWS SDK for Python (Boto3) zu beenden: `stop_browser_session`
**Anforderungssyntax**
Im Folgenden wird die Anforderungssyntax gezeigt:
```
response = dp_client.stop_browser_session(
browserIdentifier="aws.browser.v1",
sessionId="",
)
```
1. Verwenden Sie den folgenden Aufruf, um eine Browsersitzung mithilfe der API zu beenden:
```
# Using awscurl
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/stop?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region
```
## Browser-Streams werden aktualisiert
Sie können Browser-Streams aktualisieren, um die Automatisierung zu aktivieren oder zu deaktivieren. Dies ist nützlich, wenn Sie vertrauliche Informationen wie Anmeldeinformationen eingeben müssen, die der Agent nicht sehen soll.
**Example**
1.
```
response = dp_client.update_browser_stream(
browserIdentifier="aws.browser.v1",
sessionId="",
streamUpdate={
"automationStreamUpdate": {
"streamStatus": "DISABLED" # or "ENABLED"
}
}
)
```
1.
```
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/streams/update?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"streamUpdate": {
"automationStreamUpdate": {
"streamStatus": "ENABLED"
}
}
}'
```
1.
```
aws bedrock-agentcore update-browser-stream \
--region \
--browser-id "" \
--session-id "" \
--stream-update automationStreamUpdate={streamStatus=ENABLED}
```