Przejdź do głównej treści
Polski— Wybierz język
Menu

Bezpieczeństwo i piaskownica

Lekcja 12 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Przyznawanie AI kontroli: ryzyka
  2. Cztery zasady OpenAI
  3. Zasada najmniejszych uprawnień
  4. Piaskownica z Dockerem
  5. Filtrowanie URL
  6. Ochrona wrażliwych danych
  7. Kontrole bezpieczeństwa API
  8. Limity wykonania
  9. Lista kontrolna bezpieczeństwa produkcyjnego
  10. Kluczowe wnioski

Lekcja przepisana 3 listopada 2026 na podstawie przewodnika Computer use od OpenAI, jego przepisów integracyjnych Computer use oraz dokumentacji sieciowej Docker i Playwright. Dodatki: cztery zasady bezpieczeństwa OpenAI, poziomy potwierdzeń oraz obsługa pending_safety_checks. Poprawki: poprzednia wersja odcinała sieć kontenerowi, który musiał wywoływać API, pozostawiała proxy bez dostępu wychodzącego, akceptowała notexample.com w filtrze mającym przepuszczać tylko example.com, psuła formatowanie logów i szacowała koszty przy użyciu jednej sztywnej stawki. Źródła: Computer use · Przepisy integracyjne · Playwright i Docker · Playwright, sieć.

Przyznawanie AI kontroli: ryzyka

Computer Use daje modelowi AI możliwość działania na komputerze. To potężne narzędzie, ale może być niebezpieczne. Źle skonfigurowany agent mógłby przejść na złośliwe strony, wykonać dowolny kod lub ujawnić wrażliwe dane. To nie teoria: odwiedzona strona może zawierać instrukcje napisane dla modelu, a jeśli środowisko go nie ograniczy, model wykona je tak, jakby były Twoim poleceniem. Bezpieczeństwo nie jest opcjonalne – to fundament każdego wdrożenia produkcyjnego.

Cztery zasady OpenAI

OpenAI podsumowuje bezpieczeństwo Computer Use w czterech zasadach. Stosuj je w swojej aplikacji i w środowisku uruchomieniowym, a nie tylko w instrukcjach modelu:

  • Ogranicz środowisko. Używaj izolowanej przeglądarki lub maszyny wirtualnej, listy dozwolonych witryn i działań oraz ogranicz dostęp do tego, czego wymaga zadanie.
  • Traktuj zawartość ekranu jako niezaufaną. Tekst ze strony, dokumentu lub wynik działania narzędzia nie może nadawać uprawnień ani zastępować instrukcji użytkownika. Jeśli strona wygląda na phishing lub wstrzyknięcie promptu, agent zatrzymuje się i pyta, jak postępować.
  • Potwierdzaj działania o wysokim ryzyku. Zakupy, przesyłanie danych, zmiany destrukcyjne i wszystko, czego trudno cofnąć, pozostaje pod kontrolą użytkownika. Wpisanie wrażliwych informacji w formularz już liczy się jako transmisja.
  • Ograniczaj i weryfikuj wykonanie. Ustaw limity liczby tur, czasu trwania lub kosztu; zapewnij możliwość anulowania; weryfikuj rzeczywisty wynik, a nie tylko końcową wiadomość modelu.

Punkt wyjścia jest prosty: żądanie działania od modelu nie jest zgodą użytkownika. Twój kod decyduje, czy wykonać akcję, wstrzymać się na zatwierdzenie, czy oddać kontrolę. W przypadku serii działań zatrzymaj się przed pierwszym, które wymaga potwierdzenia.

Trzy poziomy potwierdzeń

OpenAI wyróżnia trzy sytuacje, z przykładami, które możesz przyjąć w swojej polityce:

PoziomPrzykłady podane przez OpenAI
Użytkownik przejmuje kontrolęOstatni krok zmiany hasła; obejście bariery bezpieczeństwa, np. ostrzeżenia HTTPS
Potwierdź w momencie działaniaUsuwanie danych, zmiana uprawnień lub ustawień udostępniania, rozwiązywanie CAPTCHA, instalowanie lub uruchamianie pobranego oprogramowania, wysyłanie lub publikowanie w imieniu użytkownika, transakcje finansowe, ustawienia systemowe
Wstępna zgoda możliwa w pierwotnym żądaniuLogowanie do witryny, którą użytkownik poprosił odwiedzić, wysyłanie plików, przenoszenie lub zmienianie nazw plików, przesyłanie wrażliwych danych, których konkretne użycie zostało zatwierdzone

Bez wyraźnej zgody w pierwotnym żądaniu potwierdzaj tuż przed działaniem. Nie pytaj zbyt wcześnie: pozwól agentowi działać we wszystkim, co bezpieczne, następnie zatrzymaj się w punkcie ryzyka i wyjaśnij działanie, ryzyko oraz sposób zastosowania danych lub zmiany. Jeśli użytkownik odmówi, nic się nie wykonuje, a Twój kod informuje model, co się powiodło, a co nie.

Zasada najmniejszych uprawnień

Twój agent powinien mieć dostęp tylko do minimum niezbędnego do wykonania zadania. Zacznij od izolowanej przeglądarki – nigdy od głównej przeglądarki użytkownika, która przechowuje otwarte sesje poczty, bankowości i narzędzi wewnętrznych. Agent nie potrzebuje też dostępu do systemu plików poza dedykowanym folderem pobierania, nie potrzebuje dostępu do sieci wewnętrznej, chyba że wymaga tego aplikacja biznesowa, i nie powinien mieć uprawnień administratora, które mogłyby zamienić błędne kliknięcie w incydent systemowy. Nie montuj w jego środowisku plików osobistych, poświadczeń ani gniazda Dockera. Na koniec spraw, by sesja była efemeryczna: usuwaj dane po każdym uruchomieniu, aby przepływ pracy nigdy przypadkowo nie wykorzystał plików cookie ani pamięci podręcznej z poprzedniej sesji.

Piaskownica z Dockerem

Pojawiają się dwa pytania: gdzie działa przeglądarka, a gdzie pętla i klucz API? Przepis Dockera od OpenAI izoluje pulpit w kontenerze bez sieci, sterowanym z hosta przez docker exec: tylko SDK na hoście odczytuje klucz. To najszczelniejsza konfiguracja, ale działa tylko dla zadań niewymagających internetu. W przypadku innych zadań OpenAI wymaga środowiska, którego sieć wychodząca pozwala wyłącznie na witryny związane z zadaniem.

Jeśli używasz Playwright i agent musi przeglądać, możesz umieścić pętlę i przeglądarkę w tym samym kontenerze, pod warunkiem spełnienia trzech warunków: użytkownik nieuprzywilejowany, przeglądarka nie dziedzicząca zmiennych środowiskowych (więc nie otrzyma klucza) oraz sieć wychodząca ograniczona do witryn zadania i API.

# Obraz Playwright dla Pythona: przeglądarki i zależności systemowe włączone
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# Pakiet playwright nie ma w obrazie: requirements.txt
# Przypnij playwright==1.64.1, tę samą wersję co obraz
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Użytkownik nieuprzywilejowany dostarczony przez obraz
USER pwuser

CMD ["python", "src/main.py"]

Playwright zaleca przypinanie wersji obrazu. Obraz dostarcza przeglądarki, nie bibliotekę Pythona: zainstaluj tę samą wersję pakietu playwright. Nie uruchamiaj kontenera jako root, co wyłącza piaskownicę Chromium. Dla niezaufanych witryn Playwright zaleca również swój profil seccomp, który dodaje wywołania systemowe potrzebne tej piaskownicy do domyślnego profilu Dockera.

docker run --rm --init \
  --network agent-net \
  --security-opt seccomp=seccomp_profile.json \
  --ipc=host \
  --memory=2g --cpus=1.5 --pids-limit=256 \
  -e OPENAI_API_KEY \
  computer-use-agent

--init zapobiega procesom zombie, a --ipc=host, zalecane przez Playwright, zapobiega wyczerpaniu pamięci współdzielonej przez Chromium i awarii. Jednak to ustawienie udostępnia przestrzeń nazw IPC hosta kontenerowi. Jeśli wolisz tego nie otwierać, zwiększ pamięć współdzieloną za pomocą --shm-size, tak jak robi to przepis OpenAI dla własnego kontenera, i przetestuj na swoich najcięższych stronach. Na koniec -e OPENAI_API_KEY bez wartości dziedziczy zmienną z Twojej sesji: klucz nie pojawia się jako tekst jawny w wierszu poleceń.

Po stronie Pythona uruchom przeglądarkę z zabezpieczeniami z przepisu OpenAI – włączona piaskownica, puste środowisko, wyłączone rozszerzenia i dostęp do systemu plików – i kieruj ją przez proxy z następnej sekcji, tak jak klienta API:

from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright

PROXY = "http://agent-proxy:3128"

# Wywołania API wychodzą przez filtrujące proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # przeglądarka nie dziedziczy zmiennych środowiskowych, więc nie klucza
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # zobacz filtrowanie URL poniżej
)
page = context.new_page()

Ukierunkowane ograniczenia sieciowe

Umieść kontener agenta w wewnętrznej sieci Docker bez dostępu zewnętrznego. Proxy Squid dołącza do tej sieci i staje się jej jedynym wyjściem; proxy jest też podłączone do zwykłej sieci. Wszystko, co nie jest wyraźnie dozwolone, z perspektywy agenta nie istnieje.

# Sieć wewnętrzna: brak bezpośredniego dostępu zewnętrznego
docker network create --internal agent-net
# Sieć wychodząca, zarezerwowana dla proxy
docker network create sortie-proxy

# Proxy Squid (obraz utrzymywany przez Canonical) z Twoją listą dozwolonych
docker run -d --name agent-proxy --network sortie-proxy \
  -v "$PWD/squid.conf:/etc/squid/squid.conf:ro" \
  ubuntu/squid:6.6-24.04_beta

# Proxy dołącza do sieci wewnętrznej: to jedyne wyjście agenta
docker network connect agent-net agent-proxy
# squid.conf: zezwalaj tylko na domeny zadania i API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Kluczowy punkt: proxy jest podłączone do obu sieci. Jeśli uruchomiłbyś je tylko w sieci wewnętrznej, samo nie miałoby dostępu wychodzącego. api.openai.com jest na liście, ponieważ w tej konfiguracji kod agenta wywołuje API z wnętrza kontenera. Przeglądarka tego nie potrzebuje: filtr URL w następnej sekcji blokuje te wywołania ze strony.

Filtrowanie URL

Druga, dokładniejsza bariera znajduje się w samej przeglądarce. Przechwytując żądania za pomocą page.route, porównaj każdy URL ze specyficzną dla zadania listą dozwolonych – często krótszą niż lista proxy – i przerywaj resztę, z czytelnym logiem każdego zablokowania. Uważaj na pułapkę porównania ciągów, przed którą ostrzega OpenAI: https://example.com.evil.test nie może przejść jako https://example.com, a odwrotnie notexample.com kończy się na example.com. Porównuj schemat, dokładny host (lub subdomenę z prefiksem kropki) i port.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Blokuj żądania do nieautoryzowanych miejsc docelowych."""

    def autorisee(url: str) -> bool:
        parties = urlparse(url)
        hote = parties.hostname or ""
        return (
            parties.scheme == "https"
            and parties.port in (None, 443)
            and any(hote == d or hote.endswith("." + d) for d in allowed_domains)
        )

    def check_navigation(route):
        if autorisee(route.request.url):
            route.continue_()
        else:
            print(f"  BLOQUÉ : {route.request.url}")
            route.abort()

    page.route("**/*", check_navigation)


# Przeglądarka potrzebuje tylko witryn zadania: wywołania API pochodzą z kodu Python, nie ze strony.
setup_url_filter(page, ["example.com"])

Ta warstwa uzupełnia proxy; nie zastępuje go. Playwright zauważa, że page.route nie przechwytuje żądań obsługiwanych przez service worker, stąd service_workers="block" w kontekście, a WebSockets używają innego mechanizmu (page.route_web_socket). Filtrowanie sieci pozostaje Twoją główną barierą.

Ochrona wrażliwych danych

Maskowanie informacji na zrzutach ekranu

Każdy zrzut ekranu trafia do API: wszystko widoczne na ekranie opuszcza Twoją infrastrukturę. OpenAI zaleca utrzymywanie poświadczeń poza tekstem strony i przechwyconymi obrazami. Jeśli ekran zawiera dane wrażliwe, zamaskuj je przed wysłaniem przechwytu do modelu. Czarny prostokąt na znanych obszarach wystarczy, pod warunkiem że znasz ich współrzędne – dlatego standaryzacja rozmiaru viewportu, omówiona wcześniej w tym kursie, pomaga. Maskowanie nie zmienia rozmiaru obrazu: współrzędne zwracane przez model pozostają ważne.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Maskuj wrażliwe obszary na przechwycie PNG."""
    img = Image.open(io.BytesIO(screenshot_bytes))
    draw = ImageDraw.Draw(img)

    for x, y, w, h in regions:
        draw.rectangle([x, y, x + w, y + h], fill="black")

    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return buffer.getvalue()

Wiedza o losie przechwytów

Odpowiedzi Responses API są domyślnie przechowywane: to umożliwia łańcuchowanie przez previous_response_id. Przy store: false musisz samodzielnie resendować elementy z poprzednich tur. OpenAI zauważa również, że store: false nie eliminuje wszystkich form przechowywania, a obrazy wejściowe mają własne wyjątki: przeczytaj jego kontrolki danych przed wysłaniem ekranów zawierających dane osobowe.

Nigdy nie loguj wrażliwych danych

To samo rozumowanie dotyczy logów, które często przetrwają znacznie dłużej niż przechwyty. Filtr logowania przepisuje ryzykowne wzorce przed zapisem: przypisania haseł, klucze API OpenAI zaczynające się od sk- oraz 16-cyfrowe sekwencje przypominające numery kart. Filtr działa na finalnej wiadomości, więc wyłapuje też to, co zalogowałeś bez zastanowienia.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Maskuj wrażliwe dane przed zapisem logów."""

    PATTERNS = [
        (re.compile(r"password['\"]?\s*[:=]\s*['\"]?[^\s,}]+", re.IGNORECASE), "password=***"),
        (re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "sk-***"),
        (re.compile(r"\b\d{16}\b"), "****-****-****-****"),
    ]

    def filter(self, record):
        msg = record.getMessage()
        for pattern, replacement in self.PATTERNS:
            msg = pattern.sub(replacement, msg)
        record.msg = msg
        record.args = None  # wiadomość już sformatowana: nie formatuj jej ponownie
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # na handlerze widzi też logery potomne
logging.basicConfig(level=logging.INFO, handlers=[handler])

Dwa szczegóły robią różnicę. Ustawienie record.args na None jest kluczowe: w przeciwnym razie już sformatowana wiadomość zostałaby sformatowana ponownie z argumentami, a każde % w URL zepsułoby zapis. Filtr na handlerze dotyczy wszystkiego, co zapisuje, podczas gdy filtr na loggerze ignoruje wiadomości od jego loggerów potomnych.

Kontrole bezpieczeństwa API

Każde computer_call niesie pole pending_safety_checks: listę kontroli bezpieczeństwa, które API prosi Cię obsłużyć przed wykonaniem działań, każda z id, code i message. Oficjalny przykład OpenAI zatrzymuje się, gdy lista nie jest pusta. Jeśli Twoja aplikacja może mieć człowieka walidującego te przypadki, potwierdź je wyraźnie, zwracając je w acknowledged_safety_checks wraz z następnym zrzutem ekranu. Model nie może nadać tej zgody w Twoim imieniu, a potwierdzenie następuje przed wykonaniem działania, nigdy po.

def valider_verifications(appel) -> list[dict]:
    """Przedstaw oczekujące kontrole operatorowi; domyślnie odmów."""
    if not appel.pending_safety_checks:
        return []
    for verification in appel.pending_safety_checks:
        print(f"Vérification de sécurité [{verification.code}] : {verification.message}")
    if input("Autoriser ces actions ? [o/N] ").strip().lower() != "o":
        raise RuntimeError("Actions refusées par l'opérateur")
    return [
        {"id": v.id, "code": v.code, "message": v.message}
        for v in appel.pending_safety_checks
    ]


# W pętli, przed wykonaniem działań:
acquittees = valider_verifications(appel)
executer_actions(page, appel.actions)
sortie = {
    "type": "computer_call_output",
    "call_id": appel.call_id,
    "output": {
        "type": "computer_screenshot",
        "image_url": f"data:image/png;base64,{capturer_ecran(page)}",
        "detail": "original",
    },
}
if acquittees:
    sortie["acknowledged_safety_checks"] = acquittees

Limity wykonania

Istnieje też najczęstsze ryzyko: agent, który wymyka się spod kontroli, niczego nie psując, ale działa dwie godziny i przepala budżet. Klasa ExecutionLimits egzekwuje trzy sufity – liczba tur, czas trwania i szacowany koszt – i zgłasza wyjątek, gdy którykolwiek zostanie osiągnięty. Stawki nie są sztywne: pobierz je z modelu, którego używasz, ze strony cennika OpenAI, ponieważ różnią się w zależności od modelu.

import time

class ExecutionLimits:
    """Egzekwuj sufity liczby tur, czasu trwania i kosztu dla agenta."""

    def __init__(
        self,
        prix_entree_par_million: float,  # stawki dla używanego modelu
        prix_sortie_par_million: float,
        max_tours: int = 50,
        max_duree_s: int = 300,
        max_cout_usd: float = 5.0,
    ):
        self.prix_entree = prix_entree_par_million
        self.prix_sortie = prix_sortie_par_million
        self.max_tours = max_tours
        self.max_duree = max_duree_s
        self.max_cout = max_cout_usd
        self.debut = time.monotonic()
        self.tours = 0
        self.cout = 0.0

    def verifier(self):
        """Wywołaj przed każdym żądaniem: zgłoś błąd, jeśli osiągnięto sufit."""
        if self.tours >= self.max_tours:
            raise RuntimeError(f"Limite de tours atteinte ({self.max_tours})")
        if time.monotonic() - self.debut >= self.max_duree:
            raise RuntimeError(f"Durée maximale dépassée ({self.max_duree} s)")
        if self.cout >= self.max_cout:
            raise RuntimeError(f"Budget dépassé ({self.cout:.2f} $)")

    def compter(self, response):
        """Wywołaj po każdej odpowiedzi: akumuluj tury i szacowany koszt."""
        self.tours += 1
        self.cout += response.usage.input_tokens / 1_000_000 * self.prix_entree
        self.cout += response.usage.output_tokens / 1_000_000 * self.prix_sortie

To tylko szacunek: zawyża tokeny wejściowe obsługiwane z pamięci podręcznej promptu, które są rozliczane po obniżonej stawce, i ignoruje wszelkie środowiska hostowane, rozliczane osobno. Porównuj go regularnie z rzeczywistym użyciem projektu. Ustawiaj sufity na przepływ pracy: 30-sekundowy test E2E i godzinne wprowadzanie faktur nie wymagają tych samych progów.

Lista kontrolna bezpieczeństwa produkcyjnego

Przed wdrożeniem agenta Computer Use do produkcji sprawdź:

  • Izolowana przeglądarka lub pulpit (kontener lub maszyna wirtualna), użytkownik nieuprzywilejowany
  • Sieć wychodząca ograniczona do witryn zadania i do API, jeśli pętla działa w tym samym środowisku
  • Filtr URL porównujący schemat, host i port; service workery zablokowane
  • Klucz API trzymany poza kodem i poza zasięgiem przeglądarki (env={})
  • Zawartość ekranu traktowana jako niezaufana: zatrzymaj i eskaluj przy pierwszym znaku wstrzyknięcia
  • Potwierdzenie człowieka przed zakupami, wysyłkami, usunięciami i wprowadzaniem danych wrażliwych
  • pending_safety_checks nigdy nie potwierdzane bez walidacji człowieka
  • Limity liczby tur, czasu trwania i kosztu
  • Filtrowane logi, przechwyty nieprzechowywane (lub szyfrowane)
  • Brak montowania plików osobistych, poświadczeń lub gniazda Dockera w środowisku
  • Wynik zweryfikowany w aplikacji przed ogłoszeniem sukcesu
  • Mechanizm awaryjnego zatrzymania (kill switch)

Ostatni punkt jest najczęściej zapominany, a jednak to jedyny, który pomaga, gdy wszystkie inne zawiodą. Kill switch to sposób na natychmiastowe przerwanie działania agenta, bez czekania, aż osiągnie któryś z limitów: plik STOP, który pętla sprawdza w każdej iteracji, docker stop na kontenerze lub flaga odczytywana ze zmiennej współdzielonej. Przetestuj go przed produkcją, nie w dniu, gdy go potrzebujesz.

Kluczowe wnioski

  • Cztery zasady OpenAI: ogranicz środowisko, traktuj ekran jako niezaufany, potwierdzaj działania o wysokim ryzyku oraz ograniczaj i weryfikuj wykonanie
  • Żądanie działania od modelu nie jest zgodą: Twój kod wykonuje, wstrzymuje lub oddaje kontrolę
  • Izoluj przeglądarkę (użytkownik nieuprzywilejowany, profil seccomp) i zezwalaj na ruch wychodzący tylko do witryn zadania
  • Filtruj URL, porównując schemat, host i port – nigdy przez prosty prefiks lub sufiks ciągu
  • Potwierdzaj pending_safety_checks tylko po walidacji człowieka
  • Egzekwuj limity liczby tur, czasu trwania i kosztu oraz weryfikuj rzeczywisty wynik