Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Varnost in pesčenje

Lekcija 12 od 14 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Dajanje nadzora umetni inteligenci: tveganja
  2. Štiri pravila OpenAI
  3. Načelo najmanjših privilegijev
  4. Pesčenje z Dockerjem
  5. Filtriranje URL-jev
  6. Varovanje občutljivih podatkov
  7. Varnostni preverki API-ja
  8. Omejitve izvajanja
  9. Kontrolni seznam varnosti za produkcijo
  10. Ključne ugotovitve

Lekcija prepisana 3. novembra 2026 na podlagi vodnika Computer use podjetja OpenAI, njegovih receptov za integracijo Computer use ter dokumentacije o mreženju za Docker in Playwright. Dodatki: štiri varnostna pravila OpenAI, ravni potrditve in priznavanje pending_safety_checks. Popravki: prejšnja različica je prekinila omrežje za vsebnik, ki je moral klicati API, pustila proxy brez odhodnega dostopa, sprejela notexample.com v filtru, namenjenem samo za example.com, pokvarila oblikovanje dnevnikov in ocenjevala stroške z uporabo ene same vgrajene stopnje. Viri: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.

Dajanje nadzora umetni inteligenci: tveganja

Computer Use omogoča modelu umetne inteligence delovanje na računalniku. To je zmogljivo, a lahko nevarno. Napačno konfiguriran agent bi lahko obiskal zlonamerne strani, izvajal poljubno kodo ali razkril občutljive podatke. To ni teoretično: obiskana stran lahko vsebuje navodila, napisana za model, in če ga okolje ne omejuje, jih bo model upošteval, kot da so tvoja zahteva. Varnost ni izbira – je temelj vsakega produkcijskega uvajanja.

Štiri pravila OpenAI

OpenAI povzema varnost Computer Use v štirih pravilih. Uporabi jih v svoji aplikaciji in v izvajalnem okolju, ne le v navodilih modela:

  • Omeji okolje. Uporabi izoliran brskalnik ali navidezni stroj, seznam dovoljenih strani in dejanj ter omeji dostop le na tisto, kar naloga zahteva.
  • Vsebino zaslona obravnavaj kot nezaupljivo. Besedilo s strani, dokumenta ali izhod orodja ne more podeliti dovoljenja ali nadomestiti uporabnikovih navodil. Če stran izgleda kot ribarjenje (phishing) ali vbrizganje poziva (prompt injection), agent ustavi delovanje in vpraša, kako nadaljevati.
  • Potrdi dejanja z visokimi vlogami. Nakupi, prenos podatkov, destruktivne spremembe in vse, kar je težko razveljaviti, ostanejo pod uporabnikovim nadzorom. Vnos občutljivih informacij v obrazec že šteje kot prenos.
  • Omeji in preveri izvajanje. Nastavi omejitve za število korakov, trajanje ali stroške; zagotovi možnost preklica; in preveri dejanski izid, ne le končnega sporočila modela.

Izhodišče je preprosto: zahteva modela za delovanje ni uporabniško dovoljenje. Tvoja koda odloči, ali naj se dejanje izvrši, začasno ustavi za odobritev ali vrne nadzor nazaj. Pri nizu dejanj se ustavi pred prvim, ki zahteva potrditev.

Tri ravni potrditve

OpenAI razlikuje tri situacije s primeri, ki jih lahko vključiš v svojo politiko:

RavenPrimeri, ki jih navaja OpenAI
Uporabnik prevzame nadzorZadnji korak spremembe gesla; obhod varnostne pregrade, kot je opozorilo HTTPS
Potrditev v trenutku dejanjaBrisanje podatkov, spreminjanje dovoljenj ali nastavitev skupne rabe, reševanje CAPTCHA, namestitev ali zagon prenesene programske opreme, pošiljanje ali objavljanje v imenu uporabnika, finančne transakcije, sistemske nastavitve
Predhodna odobritev mogoča v začetni zahteviPrijava na stran, ki jo je uporabnik zahteval obiskati, pošiljanje datotek, premikanje ali preimenovanje datotek, prenos občutljivih podatkov, katerih specifična uporaba je bila odobrena

Brez jasne odobritve v začetni zahtevi potrdi tik pred dejanjem. Ne vprašaj prezgodaj: pusti agentu, da nadaljuje z vsem, kar je varno, nato se ustavi na točki tveganja in pojasni dejanje, tveganje ter kako bodo podatki ali sprememba uporabljeni. Če uporabnik zavrne, se nič ne izvrši, tvoja koda pa modelu sporoči, kaj je uspelo in kaj ne.

Načelo najmanjših privilegijev

Tvoj agent bi moral imeti dostop le do absolutnega minimuma, potrebnega za dokončanje naloge. Začni z izoliranim brskalnikom – nikoli z uporabnikovim glavnim brskalnikom, ki hrani odprte seje za e-pošto, bančništvo in interna orodja. Agent tudi ne potrebuje dostopa do datotečnega sistema, razen do namenske mape za prenose, ne potrebuje dostopa do notranjega omrežja, razen če to zahteva poslovna aplikacija, in ne sme imeti skrbniških pravic, ki bi lahko iz napačnega klika naredile sistemski incident. Ne priklop osebnih datotek, poverilnic ali vtičnice Docker v njegovo okolje. Nazadnje, naj bo seja efemerna: izbriši podatke po vsakem zagonu, da delovni tok nikoli pomotoma ne ponovno uporabi piškotkov ali predpomnilnika iz prejšnjega zagona.

Pesčenje z Dockerjem

Pojavita se dve vprašanji: kje se izvaja brskalnik in kje sta zanka ter ključ API? Recept Docker podjetja OpenAI izolira namizje v vsebniku brez omrežja, ki ga gostitelj nadzira prek docker exec: le SDK na gostitelju bere ključ. To je najstrožja konfiguracija, vendar deluje le za naloge, ki ne potrebujejo interneta. Za druge naloge OpenAI zahteva okolje, katerega odhodno omrežje dovoljuje le strani za nalogo.

Če obdržiš Playwright in mora agent brskati, lahko postaviš zanko in brskalnik v isti vsebnik, pod pogojem treh pogojev: neprivilegiran uporabnik, brskalnik, ki ne podeduje spremenljivk okolja (torej ne dobi ključa), in odhodno omrežje, omejeno na strani za nalogo in API.

# Slika Playwright za Python: brskalniki in sistemske odvisnosti vključeni
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# Paket playwright ni v sliki: requirements.txt
# Pripni playwright==1.64.1, enako različico kot slika
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Neprivilegiran uporabnik, ki ga zagotavlja slika
USER pwuser

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

Playwright priporoča pripnanje različice slike. Slika zagotavlja brskalnike, ne knjižnice Python: namesti enako različico paketa playwright. Ne zaganjaj vsebnika kot root, kar onemogoči peskovnik Chromium. Za nezaupljive strani Playwright priporoča tudi svoj profil seccomp, ki privzetemu profilu Dockerja doda sistemske klice, potrebne za ta peskovnik.

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 preprečuje procese zombije, --ipc=host, ki ga priporoča Playwright, pa preprečuje, da bi Chromium porabil vso skupno pomnilniško prostor in se zrušil. Vendar ta nastavitev deli imenski prostor IPC gostitelja z vsebnikom. Če tega ne želiš odpreti, namesto tega povečaj skupni pomnilnik z --shm-size, kot to počne recept OpenAI za svoj vsebnik, in testiraj na svojih najzahtevnejših straneh. Končno, -e OPENAI_API_KEY brez vrednosti podeduje spremenljivko iz tvoje seje: ključ se ne pojavi v navadni obliki na ukazni vrstici.

Na strani Python zaženi brskalnik s previdnostnimi ukrepi iz recepta OpenAI – omogočen peskovnik, prazno okolje, onemogočene razširitve in dostop do datotečnega sistema – ter ga usmeri prek proxyja iz naslednjega razdelka, tako kot odjemalca API:

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

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

# Klici API gredo ven skozi filtrirni proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # brskalnik ne podeduje spremenljivk okolja, torej ne ključa
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # glej filtriranje URL spodaj
)
page = context.new_page()

Ciljno omejevanje omrežja

Postavi vsebnik agenta v notranje omrežje Docker brez zunanjega dostopa. Proxy Squid se pridruži temu omrežju in postane njegov edini izhod; proxy je povezan tudi z običajnim omrežjem. Vse, kar ni izrecno dovoljeno, z vidika agenta ne obstaja.

# Notranje omrežje: brez neposrednega zunanjega dostopa
docker network create --internal agent-net
# Odhodno omrežje, rezervirano za proxy
docker network create sortie-proxy

# Proxy Squid (slika, ki jo vzdržuje Canonical) s tvojim seznamom dovoljenih
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 se pridruži notranjemu omrežju: to je edini izhod za agenta
docker network connect agent-net agent-proxy
# squid.conf: dovoli le domene za nalogo in API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Ključna točka: proxy je povezan z obema omrežjema. Če bi ga zagnal le v notranjem omrežju, sam ne bi imel odhodnega dostopa. api.openai.com je na seznamu, ker v tej nastavitvi koda agenta kliče API iznoter vsebnika. Brskalnik ga ne potrebuje: filter URL v naslednjem razdelku blokira te klice s strani.

Filtriranje URL-jev

Druga, natančnejša pregrada živi v samem brskalniku. S prestrezanjem zahtev z page.route primerjaj vsak URL s seznamom dovoljenih domen, specifičnim za nalogo – ki je pogosto krajši od proxyjevega – in preostale prekini z berljivim dnevnikom vsakega bloka. Pozor na past primerjave nizov, na katero opozarja OpenAI: https://example.com.evil.test ne sme iti skozi kot https://example.com, in obratno notexample.com se konča z example.com. Primerjaj shemo, točen gostitelj (ali poddomeno s piko na začetku) in vrata.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Blokiraj zahteve na nepooblaščena ciljna mesta."""

    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)


# Brskalnik potrebuje le strani za nalogo: klici API prihajajo iz tvoje kode Python, ne s strani.
setup_url_filter(page, ["example.com"])

Ta plast dopolnjuje proxy; ne nadomešča ga. Playwright ugotavlja, da page.route ne prestreže zahtev, ki jih obravnava delavec storitve (service worker), zato service_workers="block" v kontekstu, in WebSockets uporabljajo drugačen mehanizem (page.route_web_socket). Filtriranje omrežja ostaja tvoja primarna pregrada.

Varovanje občutljivih podatkov

Maskiranje informacij na posnetkih zaslona

Vsak posnetek zaslona gre v API: vse, kar je vidno na zaslonu, zapusti tvojo infrastrukturo. OpenAI priporoča, da poverilnic ne vključuješ v besedilo strani in zajeme. Če zaslon vsebuje občutljive podatke, jih zamaskiraj, preden pošlješ zajem modelu. Črn pravokotnik čez znana območja zadostuje, pod pogojem, da poznaš njihove koordinate – zato standardizacija velikosti vidnega polja, kot je obravnavano prej v tem tečaju, pomaga. Maskiranje ne spremeni velikosti slike: koordinate, ki jih vrne model, ostanejo veljavne.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Maskiraj občutljiva območja na posnetku 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()

Poznavanje usode zajemov

Odgovori API Responses so privzeto shranjeni: to omogoča veriženje prek previous_response_id. Z store: false moraš sam znova poslati elemente iz prejšnjih korakov. OpenAI tudi ugotavlja, da store: false ne odpravi vseh oblik hrambe, vhodne slike pa imajo svoje izjeme: pred pošiljanjem zaslonov, ki vsebujejo osebne podatke, preberi njihove kontrole podatkov.

Nikoli ne beleži občutljivih podatkov

Enako razmišljanje velja za dnevnike, ki pogosto preživijo veliko dlje kot zajemi. Filter za beleženje prepíše tvegane vzorce pred zapisovanjem: dodelitve gesel, ključe API OpenAI, ki se začnejo s sk-, in 16-mestna zaporedja, ki spominjajo na številke kartic. Filter deluje na končnem sporočilu, zato ujame tudi tisto, kar si zabeležil brez razmisleka.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Maskiraj občutljive podatke pred zapisovanjem dnevnikov."""

    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  # sporočilo je že oblikovano: ne oblikuj ga znova
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # na rokovalcu vidi tudi podrejene beležilnike
logging.basicConfig(level=logging.INFO, handlers=[handler])

Dve podrobnosti naredita razliko. Nastavitev record.args na None je bistvena: sicer bi bilo že oblikovano sporočilo znova oblikovano z njegovimi argumenti in vsak % v URL-ju bi pokvaril zapis. In filter na rokovalcu velja za vse, kar zapiše, medtem ko filter na beležilniku ignorira sporočila od njegovih podrejenih beležilnikov.

Varnostni preverki API-ja

Vsak computer_call nosi polje pending_safety_checks: seznam varnostnih preverkov, ki jih API zahteva, da jih obravnavaš pred izvršitvijo dejanj, vsak z id, code in message. Uradni primer OpenAI se ustavi takoj, ko ni prazen. Če tvoja aplikacija omogoča, da človek potrdi te primere, jih izrecno priznaj z vrnitvijo v acknowledged_safety_checks, skupaj z naslednjim posnetkom zaslona. Model tega odobrenja ne more podeliti v tvojem imenu, priznanje pa pride pred izvršitvijo dejanja, nikoli po njem.

def valider_verifications(appel) -> list[dict]:
    """Predloži čakajoče preverke operaterju; privzeto zavrnitev."""
    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
    ]


# V zanki, pred izvršitvijo dejanj:
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

Omejitve izvajanja

Obstaja tudi najpogostejše tveganje: agent, ki uide iz tira, ne da bi kaj pokvaril, a teče dve uri in požge tvoj proračun. Razred ExecutionLimits uveljavlja tri stropove – število korakov, trajanje in ocenjeni strošek – in sproži izjemo, takoj ko je eden dosežen. Stopnje niso vgrajene: pridobi jih iz modela, ki ga uporabljaš, na strani s cenami podjetja OpenAI, saj se razlikujejo glede na model.

import time

class ExecutionLimits:
    """Uveljavi strope za število korakov, trajanje in strošek na agentu."""

    def __init__(
        self,
        prix_entree_par_million: float,  # stopnje za uporabljeni model
        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):
        """Pokliči pred vsako zahtevo: sproži napako, če je dosežen strop."""
        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):
        """Pokliči po vsakem odgovoru: seštej korake in ocenjeni strošek."""
        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 je le ocena: precenjuje vhodne žetone, servirane iz predpomnilnika pozivov, ki se zaračunavajo po znižani stopnji, in ignorira morebitno gostovano okolje, ki se zaračunava ločeno. Redno jo primerjaj z dejansko uporabo tvojega projekta. Nastavi strope na delovni tok: 30-sekundni test E2E in urni vnos računov ne zahtevata istih pragov.

Kontrolni seznam varnosti za produkcijo

Pred uvajanjem agenta Computer Use v produkcijo preveri:

  • Izoliran brskalnik ali namizje (vsebnik ali navidezni stroj), neprivilegiran uporabnik
  • Odhodno omrežje omejeno na strani za nalogo in na API, če zanka teče v istem okolju
  • Filter URL, ki primerja shemo, gostitelja in vrata; delavci storitev blokirani
  • Ključ API kept izven kode in izven dosega brskalnika (env={})
  • Vsebina zaslona obravnavana kot nezaupljiva: ustavi in eskaliraj ob prvem znaku vbrizganja
  • Človeška potrditev pred nakupi, pošiljanjem, brisanjem in vnosom občutljivih podatkov
  • pending_safety_checks nikoli priznani brez človeške validacije
  • Omejitve za število korakov, trajanje in stroške
  • Filtrirani dnevniki, zajemi niso shranjeni (ali so šifrirani)
  • Brez osebnih datotek, poverilnic ali vtičnice Docker, priklopljenih v okolje
  • Rezultat preverjen v aplikaciji pred razglasitvijo uspeha
  • Mehanizem za nujni zaustav (kill switch)

Zadnja točka je tista, ki jo najpogosteje pozabimo, vendar je edina, ki pomaga, ko vse druge odpovedo. Kill switch je način za takojšnjo prekinitev agenta, brez čakanja, da doseže eno od svojih omejitev: datoteka STOP, ki jo zanka preveri pri vsaki iteraciji, docker stop na vsebniku ali zastavica, prebrana iz skupne spremenljivke. Testiraj ga pred produkcijo, ne na dan, ko ga potrebuješ.

Ključne ugotovitve

  • Štiri pravila OpenAI: omeji okolje, obravnavaj zaslon kot nezaupljiv, potrdi dejanja z visokimi vlogami ter omeji in preveri izvajanje
  • Zahteva modela za delovanje ni dovoljenje: tvoja koda izvrši, začasno ustavi ali vrne nadzor nazaj
  • Izoliraj brskalnik (neprivilegiran uporabnik, profil seccomp) in dovoli odhodni promet le na strani za nalogo
  • Filtriraj URL-je s primerjavo sheme, gostitelja in vrat – nikoli s preprostim predpono ali pripono niza
  • Priznaj pending_safety_checks šele po človeški validaciji
  • Uveljavi omejitve za število korakov, trajanje in stroške ter preveri dejanski izid