Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Slándáil agus bosáil ghainimh

Ceacht 12 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Smacht a thabhairt d’AI: na rioscaí
  2. Ceithre riail OpenAI
  3. Prionsabal na pribhléide is lú
  4. Bosáil ghainimh le Docker
  5. Scagadh URL
  6. Sonraí íogaire a chosaint
  7. Seiceálacha sábháilteachta API
  8. Teorainneacha feidhmithe
  9. Seicliosta slándála táirgthe
  10. Príomhphointí

An ceacht athscríofa an 3 Samhain, 2026 bunaithe ar threoir Computer use ó OpenAI, a chuid Computer use integration recipes, agus doiciméadú líonraithe Docker agus Playwright. Breiseáin: ceithre riail slándála OpenAI, a leibhéil deimhnithe, agus an t-aithint ar pending_safety_checks. Ceartúcháin: ghearr an leagan roimhe seo an líonra do choimeádán a raibh gá aige glaoch ar an API, d’fhág sé an seachfhreastalaí gan rochtain amach, ghlac sé le notexample.com i scagaire a bhí ceaptha gan cead a thabhairt ach do example.com, bhris sé formáidiú log, agus rinne sé meastachán ar chostais ag baint úsáide as ráta amháin crua-chódaithe. Foinse: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.

Smacht a thabhairt d’AI: na rioscaí

Tugann Computer Use cumas do mhúnla AI gníomhú ar ríomhaire. Tá sé sin cumhachtach, ach is féidir leis a bheith contúirteach. D’fhéadfadh gníomhaire míchumraithe dul chuig suíomhanna mailíseacha, cód treallach a rith, nó sonraí íogaire a nochtadh. Níl sé seo teoiriciúil: d’fhéadfadh treoracha scríofa don mhúnla a bheith ar leathanach a dtugtar cuairt air, agus mura gcuireann an timpeallacht srian air, leanfaidh an múnla iad amhail is gur iarratas uaitse a bhí ann. Níl rogha agat maidir le slándáil—is í bunús aon imlonnú táirgthe í.

Ceithre riail OpenAI

Déanann OpenAI achoimre ar shlándáil Computer Use i gceithre riail. Cuir i bhfeidhm iad i d’fheidhmchlár agus sa timpeallacht rithime, ní hamháin i dtreoracha an mhúnla:

  • Cuir srian ar an timpeallacht. Úsáid brabhsálaí nó meaisín fíorúil leithlisithe, liosta ceadaithe de shuíomhanna agus gníomhaíochtaí, agus teorainn rochtana leis an méid a theastaíonn don tasc.
  • Cáil ábhar na scáileáine mar neamhiontaofa. Ní féidir le téacs ó leathanach, doiciméad, nó aschur uirlise cead a thabhairt ná treoracha úsáideora a chur in ionad. Má tá cuma phishing nó instealladh pras ar leathanach, stopann an gníomhaire agus fiafraíonn sé conas dul ar aghaidh.
  • Deimhnigh gníomhaíochtaí ardstoc. Fanann ceannacháin, tarchur sonraí, athruithe millteacha, agus aon rud atá deacair a chur ar ais faoi smacht an úsáideora. Meastar gur tarchur é cheana féin faisnéis íogaire a chlóscríobh i bhfoirm.
  • Teorainn a chur le feidhmiú agus é a fhíorú. Socraigh teorainneacha ar thimthriallta, fad, nó costas; soláthair bealach chun cealú; agus fíoraigh an toradh iarbhír, ní hamháin teachtaireacht dheiridh an mhúnla.

Is simplí an pointe tosaigh: ní cead ón úsáideoir é an t-iarratas ón múnla gníomhú. Is é do chód a chinneann an ndéanfar é a fheidhmiú, an gcuirfear ar fionraí é le haghaidh formheasa, nó an dtabharfar an smacht ar ais. I mbaisc gníomhaíochtaí, stop roimh an gcéad cheann a éilíonn deimhniú.

Trí leibhéal deimhnithe

Déanann OpenAI idirdhealú idir trí chás, le samplaí is féidir leat a ghlacadh i do bheartas:

LeibhéalSamplaí luaite ag OpenAI
Glacann an t-úsáideoir an smacht ar aisCéim dheireanach athraithe pasfhocail; sárú bacainne slándála, mar shampla rabhadh HTTPS
Deimhnigh ag am na gníomhaíochtaSonraí a scriosadh, ceadanna nó socruithe comhroinnte a athrú, CAPTCHA a réiteach, bogearraí íoslódáilte a shuiteáil nó a rith, seoladh nó foilsiú thar ceann an úsáideora, idirbhearta airgeadais, socruithe córais
Is féidir réamhfhormheas san iarratas tosaighLogáil isteach ar shuíomh d’iarr an t-úsáideoir cuairt a thabhairt air, comhaid a sheoladh, comhaid a bhogadh nó a athainmniú, sonraí íogaire a tharchur a formheasaigh an t-úsáideoir lena n-úsáid shonrach

Gan formheas soiléir san iarratas tosaigh, déan deimhniú díreach roimh an ngníomh. Ná fiafraigh ró-luath: lig don ghníomhaire dul ar aghaidh ar gach rud atá sábháilte, ansin stop ag an bpointe riosca agus mínigh an gníomh, an riosca, agus conas a chuirfear na sonraí nó an t-athrú i bhfeidhm. Má dhiúltaíonn an t-úsáideoir, ní fheidhmítear aon rud, agus insíonn do chód don mhúnla cad a d’éirigh leis agus cad a theip.

Prionsabal na pribhléide is lú

Níor chóir go mbeadh rochtain ag do ghníomhaire ach ar an méid is lú is gá chun a thasc a chríochnú. Tosaigh le brabhsálaí leithlisithe—ná húsáid brabhsálaí príomha an úsáideora riamh, ina bhfuil seisiúin oscailte do ríomhphost, baincéireacht, agus uirlisí inmheánacha. Ní gá rochtan ar an gcóras comhad don ghníomhaire ach amháin fillteán íoslódála tiomnaithe, ní gá rochtan ar an líonra inmheánach mura n-éilíonn feidhmchlár gnó é, agus ní chóir cearta riarthóra a bheith aige a d’fhéadfadh míchliceáil a thiontú ina eachtra chórais. Ná mountáil comhaid phearsanta, dintiúir, nó soicéad Docker isteach ina thimpeallacht. Ar deireadh, déan an seisiún sealadach: scrios sonraí tar éis gach rith ionas nach n-úsáideann sreabhadh oibre fianáin nó taisce ón gceann roimhe seo go taisme riamh.

Bosáil ghainimh le Docker

Tagann dhá cheist chun cinn: cá rithfidh an brabhsálaí, agus cá mbeidh an lúb agus an eochair API? Leithlisíonn oideas Docker OpenAI deasc i gcoimeádán gan líonra, arna rialú ón óstach trí docker exec: ní léann ach an SDK ar an óstach an eochair. Is é seo an chumraíocht is doichte, ach ní oibríonn sé ach do thascanna nach bhfuil gá leis an idirlíon acu. Do thascanna eile, éilíonn OpenAI timpeallacht ina gceadaíonn an líonra amach ach suíomhanna an tasc.

Má choinníonn tú Playwright agus ní mór don ghníomhaire brabhsáil, is féidir leat an lúb agus an brabhsálaí a chur sa choimeádán céanna, ar choinníoll go gcomhlíontar trí choinníoll: úsáideoir neamh-phribhléideach, brabhsálaí nach n-oidhreacht athróga timpeallachta (ionas nach bhfaigheann sé an eochair), agus líonra amach teoranta do shuíomhanna an tasc agus don API.

# Íomhá Playwright do Python: brabhsálaithe agus spleáchais chórais san áireamh
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# Níl an pacáiste playwright san íomhá: requirements.txt
# Pin playwright==1.64.1, an leagan céanna leis an íomhá
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Úsáideoir neamh-phribhléideach arna sholáthar ag an íomhá
USER pwuser

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

Molann Playwright leagan na híomhá a phionnú. Soláthraíonn an íomhá na brabhsálaithe, ní an leabharlann Python: suiteáil an leagan céanna den phacáiste playwright. Ná rith an coimeádán mar fhréamh (root), rud a dhíchumasaíonn bosáil ghainimh Chromium. Do shuíomhanna neamhiontaofa, molann Playwright freisin a phróifíl seccomp, a chuireann na glaonna córais a theastaíonn don bhosáil ghainimh seo le próifíl réamhshocraithe Docker.

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

Cuireann --init cosc ar phróisis siombóideacha, agus coscaíonn --ipc=host, arna mholadh ag Playwright, ar Chromium rith as cuimhne roinnte agus titim. Mar sin féin, roinneann an socrú sin spás ainmneacha IPC an óstaigh leis an gcoimeádán. Mura dteastaíonn uait é a oscailt, méadaigh an chuimhne roinnte le --shm-size ina ionad, mar a dhéanann oideas OpenAI dá choimeádán féin, agus déan tástáil ar do leathanaigh is troime. Ar deireadh, seolann -e OPENAI_API_KEY gan luach an athróg ó do sheisiún: ní fheictear an eochair i ngnáth-théacs ar líne na n-orduithe.

Ar thaobh Python, seol an brabhsálaí leis na réamhchúraimí ó oideas OpenAI—bosáil ghainimh cumasaithe, timpeallacht fholamh, breiseáin agus rochtan ar an gcóras comhad díchumasaithe—agus seol é tríd an seachfhreastalaí ón gcéad chuid eile, díreach cosúil leis an gcliant API:

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

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

# Téann glaonna API amach tríd an seachfhreastalaí scagtha
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # ní oidhreachtann an brabhsálaí aon athróga timpeallachta, mar sin ní faigheann sé an eochair
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # féach scagadh URL thíos
)
page = context.new_page()

Srialta líonra spriocdhírithe

Cuir coimeádán an ghníomhaire ar líonra Docker inmheánach gan rochtan sheachtrach. Bíonn seachfhreastalaí Squid ar an líonra sin agus is é an t-aon bhealach amach é; tá an seachfhreastalaí nasctha le líonra gnáth freisin. Níl aon rud nach gceadaítear go sonrach ann ó dhearcadh an ghníomhaire.

# Líonra inmheánach: gan rochtan sheachtrach dhíreach
docker network create --internal agent-net
# Líonra amach, curtha in áirithe don seachfhreastalaí
docker network create sortie-proxy

# Seachfhreastalaí Squid (íomhá arna cothabháil ag Canonical) le do liosta ceadaithe
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

# Déanann an seachfhreastalaí nasc leis an líonra inmheánach: is é seo an t-aon bhealach amach ag an ngníomhaire
docker network connect agent-net agent-proxy
# squid.conf: ná ceadaigh ach fearainn an tasc agus an API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Is é an pointe tábhachtach: tá an seachfhreastalaí nasctha leis an dá líonra. Dá seolfá ar an líonra inmheánach amháin é, ní bheadh rochtan amach aige féin. Tá api.openai.com ar an liosta toisc, sa chumraíocht seo, go nglaonn cód an ghníomhaire ar an API laistigh den choimeádán. Ní gá don bhrabhsálaí é: cuireann an scagaire URL sa chéad chuid eile cosc ar na glaonna sin ón leathanach.

Scagadh URL

Tá bacainn níos mine ina dhara háit sa bhrabhsálaí féin. Trí iarratais a idirghabháil le page.route, déan comparáid idir gach URL agus an liosta ceadaithe atá sonrach don tasc—go minic níos giorra ná liosta an tseachfhreastalaí—agus toirmisc an chuid eile, le log inléite de gach blocáil. Bí ar an airdeall faoina gcuireann OpenAI in iúl maidir le gaiste comparáide teaghráin: ní mór do https://example.com.evil.test teacht tríd mar https://example.com, agus ar an gcaoi chéanna críochnaíonn notexample.com le example.com. Déan comparáid idir an scéim, an tóstach cruinn (nó fofhearainn le ponc os a chomhair), agus an port.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Bac iarratais chuig ceann scríbe neamhúdaraithe."""

    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)


# Ní gá don bhrabhsálaí ach suíomhanna an tasc: tagann glaonna API ó do chód Python, ní ón leathanach.
setup_url_filter(page, ["example.com"])

Comhlánaíonn an sraith seo an seachfhreastalaí; ní chuireann sé in ionad é. Tugann Playwright faoi deara nach ndéanann page.route idirghabháil ar iarratais a láimhseáiltear ag oibrí seirbhíse, dá bhrí sin service_workers="block" sa chomhthéacs, agus úsáideann WebSockets meicníocht eile (page.route_web_socket). Is é do scagadh líonra fós do phríomhbhacainn.

Sonraí íogaire a chosaint

Faisnéis a mascáil i ngabhálacha scáileáin

Téann gach gabháil scáileáin chuig an API: fágann aon rud atá le feiceáil ar an scáileán do bhonneagar. Molann OpenAI dintiúir a choinneáil as téacs agus gabhálacha leathanaigh. Má tá sonraí íogaire ar an scáileán, mascáil iad sula seolann tú an ghabháil chuig an múnla. Is leor dronuilleog dhubh thar limistéir aitheanta, ar choinníoll go bhfuil a gcomhordanáidí ar eolas agat—sin an fáth a gcuidíonn caighdeánú méid an chomhla radhairc, mar a chlúdaítear thuas sa chúrsa seo. Ní athraíonn mascáil méid na híomhá: fanann comhordanáidí arna dtabhairt ar ais ag an múnla bailí.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Limistéir íogaire a mascáil i ngabháil 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()

A fhios cad a tharlaíonn do ghabhálacha

Stóráiltear freagraí API Responses de réir réamhshocraithe: sin é a chumasaíonn slabhrú trí previous_response_id. Le store: false, ní mór duit eilimintí ó thimthriallta roimhe seo a athsheoladh tú féin. Tugann OpenAI faoi deara freisin nach n-eisíonn store: false gach foirm coinneála, agus tá eisceachtaí dá gcuid féin ag íomhánna ionchuir: léigh a rialuithe sonraí sula seolann tú scáileáin ina bhfuil sonraí pearsanta.

Ná logáil sonraí íogaire riamh

Baineann an réasúnaíocht chéanna le logaí, a mhaireann go minic i bhfad níos faide ná gabhálacha. Athscríobhann scagaire logála patrúin riosca sula scríobhtar: sannacháin pasfhocail, eochracha API OpenAI a thosaíonn le sk-, agus seichimh 16 dhigit a bhfuil cuma uimhreacha cárta orthu. Feidhmíonn an scagaire ar an teachtaireacht dheiridh, mar sin gabhann sé freisin an rud a logáil tú gan smaoineamh air.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Sonraí íogaire a mascáil sula scríobhtar logaí."""

    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  # tá an teachtaireacht formáidithe cheana: ná déan í a fhoirmiú arís
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # ar an láimhseálaí, feiceann sé logálaithe leanaigh freisin
logging.basicConfig(level=logging.INFO, handlers=[handler])

Déanann dhá shonraí an difríocht. Tá sé riachtanach record.args a shocrú go None: murach sin, dhéanfaí an teachtaireacht atá formáidithe cheana a fhoirmiú arís lena hargóintí, agus bhrisfeadh aon % in URL an scríobh. Agus feidhmíonn scagaire ar an láimhseálaí ar gach rud a scríobhann sé, ach déanann scagaire ar logálaí neamhaird de theachtaireachtaí óna logálaithe leanaigh.

Seiceálacha sábháilteachta API

Iompraíonn gach computer_call réimse pending_safety_checks: an liosta seiceálacha sábháilteachta a iarrann an API ort déileáil leo sula ndéanfar na gníomhaíochtaí a fheidhmiú, gach ceann acu le id, code, agus message. Stopann sampla oifigiúil OpenAI chomh luath agus nach bhfuil sé folamh. Má is féidir le duine na cásanna seo a bhailíochtú i d’fheidhmchlár, déan iad a aithint go sainráite trí iad a thabhairt ar ais in acknowledged_safety_checks, in éineacht leis an ngabháil scáileáin seo a leanas. Ní féidir leis an múnla an formheas seo a thabhairt thar do cheann, agus tagann an t-aithint roimh fheidhmiú gníomhaíochta, ní ina dhiaidh riamh.

def valider_verifications(appel) -> list[dict]:
    """Seiceálacha ar feitheamh a chur faoi bhráid oibreora; diúltaigh de réir réamhshocraithe."""
    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
    ]


# Sa lúb, roimh gníomhaíochtaí a fheidhmiú:
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

Teorainneacha feidhmithe

Tá ann freisin an riosca is coitianta: gníomhaire a théann amú gan aon rud a bhriseadh, ach a ritheann ar feadh dhá uair an chloig agus a dhóann do bhuiséad. Forfheidhmíonn an rang ExecutionLimits trí uasteorainn—timthriallta, fad, agus costas measta—agus ardaíonn sé eisceacht chomh luath agus a shroichtear ceann acu. Níl rátaí crua-chódaithe: tarraing iad ón múnla atá á úsáid agat ar leathanach praghsála OpenAI, ós rud é go n-athraíonn siad de réir an mhúnla.

import time

class ExecutionLimits:
    """Uasteorainneacha timthrialla, faid, agus costais a fhorfheidhmiú ar an ngníomhaire."""

    def __init__(
        self,
        prix_entree_par_million: float,  # rátaí don mhúnla atá in úsáid
        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):
        """Glaoigh roimh gach iarratas: ardaigh earráid má shroichtear uasteorainn."""
        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):
        """Glaoigh tar éis gach freagra: carn timthriallta agus costas measta."""
        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

Níl ann ach meastachán: déanann sé ró-mheastachán ar thócan ionchuir a sheirbheáiltear ón taisce pras, a bhíonn billeáilte ag ráta laghdaithe, agus déanann sé neamhaird ar aon timpeallacht óstáilte, a bhíonn billeáilte ar leithligh. Déan comparáid idir é agus úsáid iarbhír do thionscadail go rialta. Socraigh uasteorainneacha in aghaidh an tsreabha oibre: ní éilíonn tástáil E2E 30 soicind agus iontráil fáltas uair an chloig na tairseacha céanna.

Seicliosta slándála táirgthe

Sula ndéanann tú gníomhaire Computer Use a imlonnú go táirgeadh, fíoraigh:

  • Brabhsálaí nó deasc leithlisithe (coimeádán nó meaisín fíorúil), úsáideoir neamh-phribhléideach
  • Líonra amach teoranta do shuíomhanna an tasc, agus don API má ritheann an lúb sa timpeallacht chéanna
  • Scagaire URL a dhéanann comparáid idir scéim, óstach, agus port; oibrithe seirbhíse blocáilte
  • Eochair API coinnithe as an gcód agus as rochtan an bhrabhsálaí (env={})
  • Ábhar scáileáine cáilte mar neamhiontaofa: stop agus déan éalú ag an gcéad chomhartha insteallta
  • Deimhniú daonna roimh cheannacháin, seoltaí, scriostaí, agus iontráil sonraí íogaire
  • pending_safety_checks gan aithint riamh gan bailíochtú daonna
  • Teorainneacha timthrialla, faid, agus costais
  • Logaí scagtha, gabhálacha gan a gcoinneáil (nó criptithe)
  • Gan comhaid phearsanta, dintiúir, ná soicéad Docker mountáilte isteach sa timpeallacht
  • Toradh fíoraithe san fheidhmchlár sula bhfógraítear rath
  • Meicníocht stop éigeandála (kill switch)

Is é an pointe deireanach an ceann is minice a dhéantar dearmad air, ach is é an t-aon cheann a chuidíonn nuair a theip ar gach ceann eile. Is bealach é kill switch chun cur isteach ar an ngníomhaire láithreach, gan fanacht leis ceann dá theorainneacha a bhualadh: comhad STOP a sheiceálann an lúb gach timthriall, docker stop ar an gcoimeádán, nó bratach a léitear ó athróg roinnte. Déan tástáil air roimh tháirgeadh, ní an lá a bheidh gá agat leis.

Príomhphointí

  • Ceithre riail OpenAI: cuir srian ar an timpeallacht, cáil an scáileán mar neamhiontaofa, deimhnigh gníomhaíochtaí ardstoc, agus cuir teorainn le feidhmiú agus fíoraigh é
  • Ní cead é an t-iarratas ón múnla gníomhú: feidhmíonn do chód, fionraíonn sé, nó tugann sé an smacht ar ais
  • Leithlisigh an brabhsálaí (úsáideoir neamh-phribhléideach, próifíl seccomp) agus ná ceadaigh trácht amach ach do shuíomhanna an tasc
  • Scag URL trí scéim, óstach, agus port a chur i gcomparáid—ná déan é riamh trí réimír nó iarmhír teaghráin simplí
  • Ná déan pending_safety_checks a aithint ach tar éis bailíochtaithe daonna
  • Forfheidhmigh teorainneacha timthrialla, faid, agus costais, agus fíoraigh an toradh iarbhír