Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Saugumas ir izoliavimas

Paskaita 12 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Dirbtinio intelekto suteikimas valdyti: rizika
  2. Keturios „OpenAI“ taisyklės
  3. Mažiausių privilegijų principas
  4. Izoliavimas naudojant „Docker“
  5. URL filtravimas
  6. Jautrių duomenų apsauga
  7. API saugumo patikros
  8. Vykdymo ribos
  9. Gamybos saugumo kontrolinis sąrašas
  10. Svarbiausi punktai

Pamoka perrašyta 2026 m. lapkričio 3 d. remiantis „OpenAI“ Computer use vadovu, jos *Computer use integration recipes” bei „Docker“ ir „Playwright“ tinklo dokumentacija. Papildymai: keturios „OpenAI“ saugumo taisyklės, patvirtinimo lygiai ir pending_safety_checks pripažinimas. Pataisymai: ankstesnė versija nutraukė konteinerio, kuriam reikėjo kreiptis į API, tinklą, paliko tarpinį serverį be išėjimo prieigos, priėmė notexample.com filtre, skirtame leisti tik example.com, sugadino žurnalų formatavimą ir įvertino išlaidas naudodama vieną įkoduotą tarifą. Šaltiniai: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.

Dirbtinio intelekto suteikimas valdyti: rizika

„Computer Use“ suteikia DI modeliui galimybę veikti kompiuteryje. Tai galinga, bet gali būti pavojinga. Neteisingai sukonfigūruotas agentas gali naršyti kenkėjiškose svetainėse, vykdyti savavališką kodą arba atskleisti konfidencialius duomenis. Tai ne teorija: aplankyta svetainė gali turėti modeliui skirtų instrukcijų, ir jei aplinka jo nevaržo, modelis jas vykdys taip, lyg tai būtų tavo prašymas. Saugumas nėra pasirinkimas – tai bet kokio gamybinio diegimo pagrindas.

Keturios „OpenAI“ taisyklės

„OpenAI“ apibendrina „Computer Use“ saugumą keturiomis taisyklėmis. Taikyk jas savo programoje ir vykdymo aplinkoje, o ne tik modelio instrukcijose:

  • Apribok aplinką. Naudok izoliuotą naršyklę arba virtualią mašiną, leidžiamų svetainių ir veiksmų sąrašą bei apribok prieigą tik tuo, ko reikia užduočiai.
  • Ekrano turinį laikyk nepatikimu. Tekstas iš puslapio, dokumento ar įrankio išvesties negali suteikti leidimo ar pakeisti naudotojo instrukcijų. Jei puslapis atrodo kaip sukčiavimas ar raginimų injekcija, agentas sustoja ir klausia, kaip elgtis.
  • Patvirtink didelės rizikos veiksmus. Pirkimai, duomenų siuntimas, destruktyvūs pakeitimai ir visa, ką sunku atšaukti, lieka naudotojo kontrolei. Jautrios informacijos įvedimas į formą jau laikomas siuntimu.
  • Apribok ir patikrink vykdymą. Nustatyk ėjimų, trukmės ar išlaidų ribas; suteik galimybę atšaukti; ir patikrink faktinį rezultatą, o ne tik galutinį modelio pranešimą.

Pradžia paprasta: modelio prašymas veikti nėra naudotojo leidimas. Tavo kodas sprendžia, ar vykdyti, ar sustabdyti patvirtinimui, ar grąžinti kontrolę. Veiksmų grupės atveju sustok prieš pirmąjį veiksmą, reikalaujantį patvirtinimo.

Trys patvirtinimo lygiai

„OpenAI“ išskiria tris situacijas, kurių pavyzdžius gali taikyti savo politikoje:

Lygis„OpenAI“ cituojami pavyzdžiai
Naudotojas perima kontrolęPaskutinė slaptažodžio keitimo stadija; saugumo barjero, pvz., HTTPS įspėjimo, apeinimas
Patvirtinti veiksmo metuDuomenų trynimas, leidimų ar bendrinimo nustatymų keitimas, CAPTCHA sprendimas, atsisiųstos programinės įrangos diegimas ar vykdymas, siuntimas ar publikavimas naudotojo vardu, finansinės operacijos, sistemos nustatymai
Išankstinis patvirtinimas galimas pradiniame prašymePrisijungimas prie svetainės, kurią naudotojas paprašė aplankyti, failų siuntimas, failų perkėlimas ar pervadinimas, jautrių duomenų perdavimas, kurio konkretus naudojimas buvo patvirtintas

Be aiškaus patvirtinimo pradiniame prašyme, patvirtink tiesiai prieš veiksmą. Neklausk per anksti: leisk agentui tęsti viską, kas saugu, tada sustok rizikos taške ir paaiškink veiksmą, riziką bei tai, kaip duomenys ar pakeitimas bus pritaikyti. Jei naudotojas atsisako, niekas nevykdoma, o tavo kodas praneša modeliui, kas pavyko, o kas ne.

Mažiausių privilegijų principas

Tavo agentas turėtų turėti prieigą tik prie minimumo, reikalingo užduočiai atlikti. Pradėk nuo izoliuotos naršyklės – niekada nenaudok pagrindinės naudotojo naršyklės, kurioje atviros el. pašto, bankininkystės ir vidinių įrankių sesijos. Agentui taip pat nereikia failų sistemos prieigos, išskyrus specialų atsisiuntimų aplanką, jam nereikia vidinio tinklo prieigos, nebent to reikalauja verslo programa, ir jis neturėtų turėti administratoriaus teisių, kurios galėtų paversti neteisingą paspaudimą sistemos incidentu. Neprijunk asmeninių failų, prisijungimo duomenų ar „Docker“ lizdo prie jo aplinkos. Galiausiai, padaryk sesiją laikiną: ištrink duomenis po kiekvieno vykdymo, kad darbo eiga niekada netyčia nepakartotų slapukų ar talpyklos iš ankstesnio karto.

Izoliavimas naudojant „Docker“

Kyla du klausimai: kur veikia naršyklė ir kur yra ciklas bei API raktas? „OpenAI“ „Docker“ receptas izoliuoja darbalaukį be tinklo konteineryje, valdomame iš pagrindinio kompiuterio per docker exec: tik SDK pagrindiniame kompiuteryje skaito raktą. Tai griežčiausia konfigūracija, bet ji tinka tik užduotims, kurioms nereikia interneto. Kitoms užduotims „OpenAI“ reikalauja aplinkos, kurios išėjimo tinklas leidžia tik užduočiai skirtas svetaines.

Jei palieki „Playwright“ ir agentas turi naršyti, ciklą ir naršyklę gali dėti į tą patį konteinerį, jei tenkinamos trys sąlygos: neprivilegijuotas naudotojas, naršyklė, kuri nepaveldi aplinkos kintamųjų (kad negautų rakto), ir išėjimo tinklas, apribotas užduočiai skirtomis svetainėmis bei API.

# Playwright atvaizdas Python kalbai: naršyklės ir sistemos priklausomybės įtrauktos
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# playwright paketas nėra atvaizde: requirements.txt
# Fiksuok playwright==1.64.1, tą pačią versiją kaip ir atvaizde
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Neprivilegijuotas naudotojas, pateiktas atvaizde
USER pwuser

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

„Playwright“ rekomenduoja fiksuoti atvaizdo versiją. Atvaizdas pateikia naršykles, o ne Python biblioteką: įdiek tą pačią playwright paketo versiją. Nevykdyk konteinerio kaip root, nes tai išjungia „Chromium“ izoliaciją. Nepatikimoms svetainėms „Playwright“ taip pat rekomenduoja savo seccomp profilį, kuris prie „Docker“ numatytojo profilio prideda šiai izoliacijai reikalingus sistemos kvietimus.

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 neleidžia atsirasti zombių procesams, o --ipc=host, kurį rekomenduoja „Playwright“, neleidžia „Chromium“ išnaudoti bendrosios atminties ir užstrigti. Tačiau šis nustatymas dalijasi pagrindinio kompiuterio IPC namespace su konteineriu. Jei nenori jo atverti, vietoj to padidink bendrąją atmintį naudodamas --shm-size, kaip „OpenAI“ receptas daro savo konteineriui, ir išbandyk su sunkiausiais puslapiais. Galiausiai, -e OPENAI_API_KEY be reikšmės paveldi kintamąjį iš tavo sesijos: raktas nematomas grynuoju tekstu komandų eilutėje.

Python pusėje paleisk naršyklę laikydamasis „OpenAI“ recepto atsargumo priemonių – įjungta izoliacija, tuščia aplinka, išjungti plėtiniai ir failų sistemos prieiga – ir nukreipk ją per kitame skyriuje aprašytą tarpinį serverį, taip pat kaip ir API klientą:

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

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

# API užklausos eina per filtruojantį tarpinį serverį
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # naršyklė nepaveldi jokių aplinkos kintamųjų, taigi ir ne rakto
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # žr. URL filtravimą žemiau
)
page = context.new_page()

Tiksliniai tinklo apribojimai

Padėk agento konteinerį į vidinį „Docker“ tinklą be išorinės prieigos. „Squid“ tarpinis serveris prisijungia prie to tinklo ir tampa vieninteliu išėjimu; tarpinis serveris taip pat prijungtas prie įprasto tinklo. Viskas, kas nėra aiškiai leidžiama, agento požiūriu neegzistuoja.

# Vidinis tinklas: nėra tiesioginės išorinės prieigos
docker network create --internal agent-net
# Išėjimo tinklas, skirtas tik tarpiniam serveriui
docker network create sortie-proxy

# Squid tarpinis serveris (atvaizdą prižiūri „Canonical“) su tavo leidimų sąrašu
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

# Tarpinis serveris prisijungia prie vidinio tinklo: tai vienintelis agento išėjimas
docker network connect agent-net agent-proxy
# squid.conf: leisti tik užduočiai skirtas domenas ir API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Svarbiausias dalykas: tarpinis serveris prijungtas prie abiejų tinklų. Jei jį paleistum tik vidiniame tinkle, jis pats neturėtų išėjimo prieigos. api.openai.com yra sąraše, nes šioje sąrankoje agento kodas kreipiasi į API iš konteinerio viduje. Naršyklei jo nereikia: kitame skyriuje esantis URL filtras blokuoja tuos kvietimus iš puslapio.

URL filtravimas

Antra, tikslesnė barjera yra pačioje naršyklėje. Perimdamas užklausas su page.route, palygink kiekvieną URL su užduočiai skirtu leidimų sąrašu – dažnai trumpesniu nei tarpinio serverio – ir nutrauk likusius, pateikdamas suprantamą kiekvieno blokavimo žurnalą. Saugokis „OpenAI“ įspėjamos eilučių palyginimo spąstų: https://example.com.evil.test neturi praeiti kaip https://example.com, ir atvirkščiai, notexample.com baigiasi example.com. Palygink schemą, tikslų hostą (arba subdomeną su tašku priešdėlyje) ir prievadą.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Blokuoti užklausas į neleistinas vietas."""

    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)


# Naršyklei reikia tik užduočiai skirtų svetainių: API kvietimai ateina iš tavo Python kodo, o ne iš puslapio.
setup_url_filter(page, ["example.com"])

Šis sluoksnis papildo tarpinį serverį; jis jo nepakeičia. „Playwright“ pažymi, kad page.route neperima užklausų, apdorotų paslaugos darbuotojo (service worker), todėl kontekste naudojama service_workers="block", o „WebSocket“ naudoja kitą mechanizmą (page.route_web_socket). Tinklo filtravimas lieka tavo pagrindine barjera.

Jautrių duomenų apsauga

Informacijos maskavimas ekrano kopijose

Kiekviena ekrano kopija siunčiama į API: viskas, kas matoma ekrane, palieka tavo infrastruktūrą. „OpenAI“ rekomenduoja nelaikyti prisijungimo duomenų puslapio tekste ir fiksavimuose. Jei ekrane visgi yra jautrių duomenų, užmaskuok juos prieš siųsdamas fiksavimą modeliui. Juodas stačiakampis per žinomas sritis pakanka, jei žinai jų koordinates – todėl standartinis vaizdo dydis, aptartas anksčiau šiame kurse, padeda. Maskavimas nekeičia vaizdo dydžio: modelio grąžintos koordinatės lieka galiojančios.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Užmaskuoti jautrias sritis PNG fiksavime."""
    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()

Žinojimas, kas nutinka fiksavimams

„Responses API“ atsakymai pagal nutylėjimą saugomi: tai leidžia grandininį vykdymą per previous_response_id. Nustačius store: false, turi pats iš naujo siųsti elementus iš ankstesnių ėjimų. „OpenAI“ taip pat pažymi, kad store: false nepašalina visų saugojimo formų, o įvesties vaizdai turi savo išimtis: prieš siųsdamas ekranus su asmens duomenimis, perskaityk jos duomenų valdymą.

Niekada nerašyk jautrių duomenų į žurnalus

Tas pats pasakytina apie žurnalus, kurie dažnai išlieka daug ilgiau nei fiksavimai. Žurnalų filtras perrašo rizikingus šablonus prieš rašydamas: slaptažodžių priskyrimus, „OpenAI“ API raktus, prasidedančius sk-, ir 16 skaitmenų sekas, panašias į kortelių numerius. Filtras veikia galutinį pranešimą, todėl pagauna ir tai, ką įrašei negalvodamas.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Užmaskuoti jautrius duomenis prieš rašant žurnalus."""

    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  # pranešimas jau suformatuotas: neperformuok jo
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # ant tvarkyklės, ji mato ir vaikinius registruotojus
logging.basicConfig(level=logging.INFO, handlers=[handler])

Du detalės daro skirtumą. record.args nustatymas į None yra būtinas: kitaip jau suformatuotas pranešimas būtų performuotas su jo argumentais, ir bet koks % URL sugadintų rašymą. Filtras ant tvarkyklės taikomas viskam, ką ji rašo, tuo tarpu filtras ant registruotojo ignoruoja pranešimus iš jo vaikinių registruotojų.

API saugumo patikros

Kiekvienas computer_call turi lauką pending_safety_checks: tai saugumo patikrų, kurias API prašo tavęs aptvarkyti prieš vykdant veiksmus, sąrašas, kiekviena su id, code ir message. Oficialus „OpenAI“ pavyzdys sustoja, kai jis nėra tuščias. Jei tavo programa gali turėti žmogų, patvirtinantį šiuos atvejus, aiškiai juos pripažink grąžindamas juos acknowledged_safety_checks kartu su kita ekrano kopija. Modelis negali suteikti šio patvirtinimo tavo vardu, o pripažinimas vyksta prieš veiksmo vykdymą, niekada po.

def valider_verifications(appel) -> list[dict]:
    """Pateikti laukiančias patikras operatoriui; pagal nutylėjimą atmesti."""
    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
    ]


# Cikle, prieš vykdant veiksmus:
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

Vykdymo ribos

Yra ir dažniausia rizika: agentas, kuris išmušamas iš vėžių nieko nesulaužydamas, bet veikia dvi valandas ir sudegina tavo biudžetą. Klasė ExecutionLimits užtikrina tris lubas – ėjimus, trukmę ir numatomas išlaidas – ir išmeta išimtį, kai tik viena jų pasiekiama. Tarifai nėra įkoduoti: paimk juos iš naudojamo modelio „OpenAI“ kainodaros puslapyje, nes jie skiriasi priklausomai nuo modelio.

import time

class ExecutionLimits:
    """Užtikrinti agento ėjimų, trukmės ir išlaidų lubas."""

    def __init__(
        self,
        prix_entree_par_million: float,  # naudojamo modelio tarifai
        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):
        """Kviesti prieš kiekvieną užklausą: išmesti klaidą, jei pasiekta luba."""
        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):
        """Kviesti po kiekvieno atsakymo: kaupti ėjimus ir numatomas išlaidas."""
        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

Tai tik įvertis: jis pervertina įvesties žetonus, aptarnaujamus iš raginimų talpyklos, kurie apmokestinami mažesniu tarifu, ir nepaiso bet kokios prieglobos aplinkos, apmokestinamos atskirai. Reguliariai lygink jį su faktiniu tavo projekto naudojimu. Nustatyk lubas kiekvienai darbo eigai: 30 sekundžių E2E testas ir valandos trukmės sąskaitos įvedimas nereikalauja tų pačių slenksčių.

Gamybos saugumo kontrolinis sąrašas

Prieš diegdamas „Computer Use“ agentą į gamybą, patikrink:

  • Izoliuota naršyklė arba darbalaukis (konteineris arba virtuali mašina), neprivilegijuotas naudotojas
  • Išėjimo tinklas apribotas tik užduočiai skirtomis svetainėmis ir API, jei ciklas veikia toje pačioje aplinkoje
  • URL filtras, lyginantis schemą, hostą ir prievadą; paslaugos darbuotojai užblokuoti
  • API raktas laikomas už kodo ribų ir nepasiekiamas naršyklei (env={})
  • Ekrano turinys laikomas nepatikimu: sustok ir eskaluok pastebėjęs pirmuosius injekcijos požymius
  • Žmogaus patvirtinimas prieš pirkimus, siuntimus, trynimus ir jautrių duomenų įvedimą
  • pending_safety_checks niekada nepripažįstami be žmogaus patvirtinimo
  • Ėjimų, trukmės ir išlaidų ribos
  • Filtruojami žurnalai, fiksavimai nesaugomi (arba šifruojami)
  • Į aplinką neprijungti asmeniniai failai, prisijungimo duomenys ar „Docker“ lizdas
  • Rezultatas patikrintas programoje prieš skelbiant sėkmę
  • Avarinio sustabdymo mechanizmas (kill switch)

Paskutinis punktas yra tas, kuris dažniausiai pamirštamas, tačiau tai vienintelis, kuris padeda, kai visi kiti nepavyko. Avarinis stabdymas yra būdas nedelsiant nutraukti agento veiklą, nelaukiant, kol jis pasieks vieną iš savo ribų: STOP failas, kurį ciklas tikrina kiekvienoje iteracijoje, docker stop konteineriui arba vėliava, skaitoma iš bendrojo kintamojo. Išbandyk tai prieš gamybą, o ne tą dieną, kai to prireiks.

Svarbiausi punktai

  • Keturios „OpenAI“ taisyklės: apribok aplinką, laikyk ekraną nepatikimu, patvirtink didelės rizikos veiksmus ir apribok bei patikrink vykdymą
  • Modelio prašymas veikti nėra leidimas: tavo kodas vykdo, sustabdo arba grąžina kontrolę
  • Izoliuok naršyklę (neprivilegijuotas naudotojas, seccomp profilis) ir leisk išėjimo srautą tik į užduočiai skirtas svetaines
  • Filtruok URL lygindamas schemą, hostą ir prievadą – niekada pagal paprastą eilutės priešdėlį ar pabaigą
  • Pripažink pending_safety_checks tik po žmogaus patvirtinimo
  • Užtikrink ėjimų, trukmės ir išlaidų ribas bei patikrink faktinį rezultatą