Aplique aislamiento de la memoria del usuario final con Deep Data Security

En esta guía se muestra cómo aplicar el aislamiento del usuario final para una aplicación Oracle AI Agent Memory con OCI IAM y Oracle Deep Data Security.

Advertencia: Solo entorno de aprendizaje. No despliegue este ejemplo en producción.

La aplicación utiliza el servidor de desarrollo de Flask, un almacén de sesiones en memoria, secretos de archivos de entorno y un manejo simplificado del ciclo de vida de los tokens. Los scripts de configuración de la base de datos modifican la configuración y los privilegios del proveedor de identidad de toda la base de datos. Utiliza solo usuarios desechables y una Oracle Autonomous AI Database aislada y no de producción.

Esta guía crea una aplicación web deliberadamente pequeña:

La ruta no compara a Alice y Bob. Transfiere el token de usuario final a Oracle AI Database, donde Oracle Deep Data Security aplica la política de fila propia de la memoria del agente.

En esta guía se muestra un despliegue. Para ver la función de seguridad completa, incluidas todas las políticas, principales, funciones de administración, API de contexto de tiempo de ejecución, auditoría y tiempo de revocación soportados, consulte la referencia de seguridad y API de seguridad de datos profunda.

En esta guía:

Comprender la cadena de confianza

El explorador y la aplicación utilizan dos tokens de acceso de OAuth diferentes:

  1. El token de usuario final identifica a Alice o Bob e incluye los grupos de IAM del usuario.
  2. El token de acceso a la base de datos, obtenido por la aplicación confidencial mediante credenciales de cliente, demuestra que la aplicación puede acceder al recurso de base de datos.

Oracle AI Database valida ambos tokens antes de asociar el contexto de seguridad del usuario final.

Oracle documenta este modelo de dos tokens en Descripción del Flujo de Autenticación y los Requisitos y el ciclo de vida completo en Contexto de Seguridad de Usuario Final.

Requisitos previos

Necesita:

Oracle Deep Data Security es una autorización detallada que se aplica a la base de datos. Consulte Qué es la seguridad de datos profunda de Oracle.

Configurar el dominio de identidad de OCI IAM

Realice todo el trabajo de OCI IAM en un dominio de identidad. Registre su URL de dominio, por ejemplo, https://idcs-<id>.identity.oraclecloud.com:443.

El recorrido virtual autorizado de Oracle es Configuración de OCI IAM para el acceso mediado por aplicaciones. Los valores del siguiente ejemplo coinciden con el archivo de entorno de ejemplo proporcionado con esta guía.

Registrar el recurso de base de datos

En Dominio de identidad > Aplicaciones integradas:

  1. Agregue una aplicación confidencial denominada OracleDB.
  2. Configúrelo como servidor de recursos:
    • Público principal: OracleDB
    • Alcance: DB_ACCESS_SCOPE
  3. Configúrelo como cliente y permita credenciales de cliente.
  4. Activar.
  5. Registre su ID de aplicación, su ID de cliente y su secreto de cliente.

El ámbito de base de datos totalmente cualificado es el público concatenado con el nombre del ámbito:

OracleDBDB_ACCESS_SCOPE

Siga Registro de la base de datos en OCI IAM para ver las etiquetas de la consola actual y las descripciones de los campos.

Registrar la aplicación web

Agregue una segunda aplicación confidencial denominada OracleAgentMemoryWeb:

  1. Active Forzar permisos como autorización.
  2. Configúrelo como servidor de recursos:
    • Público principal: OracleAgentMemoryWeb
    • Alcance: APP_ACCESS_SCOPE
    • Duración del token de acceso: 3600 segundos para este ejercicio
  3. Configúrelo como un cliente con estos permisos:
    • Código de Autorización
    • Credenciales de cliente
  4. Agregue esta URL de redirección exacta: 
    http://127.0.0.1:8000/auth/callback
  5. En los recursos del cliente, otorgue acceso a ambos:
    • OracleDBDB_ACCESS_SCOPE
    • OracleAgentMemoryWebAPP_ACCESS_SCOPE
  6. Active la aplicación y registre su ID de cliente y su secreto de cliente.

La aplicación utiliza el código de autorización con state y PKCE S256. OCI IAM documenta la configuración de cliente necesaria en Registro de la aplicación en OCI IAM y proporciona un ejemplo de código de autorización de PKCE.

Agregar la reclamación del grupo

Oracle AI Database activa roles de datos asignados externamente desde la reclamación group del token de usuario final. Las reclamaciones personalizadas de OCI IAM se configuran mediante la API de REST de dominio de identidad, no la consola.

Como administrador de dominio de identidad, descargue un token de acceso personal de corta duración que pueda llamar a las API de dominio de identidad. A continuación, ejecute:

export OCI_IAM_DOMAIN_URL='https://<identity-domain-host>:443'
export OCI_IAM_ADMIN_TOKEN='<short-lived-personal-access-token>'

curl --fail-with-body \
  -X POST "$OCI_IAM_DOMAIN_URL/admin/v1/CustomClaims" \
  -H "Authorization: Bearer $OCI_IAM_ADMIN_TOKEN" \
  -H "Content-Type: application/scim+json" \
  -d '{
    "schemas": [
      "urn:ietf:params:scim:schemas:oracle:idcs:CustomClaim"
    ],
    "name": "group",
    "value": "$user.groups.*.display",
    "expression": true,
    "mode": "always",
    "tokenType": "AT",
    "allScopes": true
  }'

Una solicitud correcta devuelve HTTP 201. No cree un duplicado si el dominio ya tiene esta reclamación. Consulte Configuración de reclamaciones personalizadas para información de grupo en OCI IAM.

Crear Alice, Bob y el grupo de aplicaciones

  1. Cree un grupo denominado ORACLEAGENTMEMORY_USERS.
  2. Cree los usuarios de prueba alice y bob.
  3. Asigne ambos usuarios a ORACLEAGENTMEMORY_USERS.
  4. Asigne el grupo a OracleAgentMemoryWeb.

Posteriormente, la base de datos asignará este nombre de grupo a un rol de datos. Los nombres de grupo se comparan de forma no sensible a mayúsculas/minúsculas, pero utilizan la misma ortografía durante la configuración. Consulte Creación de usuarios y asignación de grupos en OCI IAM.

Preparar el entorno

Descargue la aplicación web completa, deepsec_oci_iam_webapp.zip. El archivo también contiene scripts de inspección y configuración de base de datos independientes propiedad de este ejemplo. No importan ni empaquetan scripts desde el conjunto de pruebas SDK.

Extraiga el archivo, introduzca su directorio de proyecto y cree archivos de entorno de tiempo de ejecución y configuración locales:

unzip deepsec_oci_iam_webapp.zip
cd deepsec_oci_iam_webapp
cp deepsec.env.example .deepsec.env
cp deepsec.runtime.env.example .deepsec.runtime.env
python -c "import secrets; print(secrets.token_hex(32))"

Ponga el valor generado en OAM_WEB_SECRET_KEY y rellene todos los marcadores de posición necesarios en ambos archivos. Ambos nombres de archivo son ignorados por Git.

El directorio database_scripts contiene:

Archivo Responsabilidad
_common.sh Ayudante privado que carga .deepsec.env, valida los valores necesarios, comprueba SQL*Plus y exporta TNS_ADMIN cuando está configurado. No lo ejecute directamente.
db_ociiam_setup.sh Activa la autenticación externa de OCI IAM para la instancia de Autonomous AI Database de destino y sustituye a OCI_IAM_DOMAIN_DB_CRED$.
db_deepsec_user_setup.sh Crea usuarios de propietario de esquema y de agrupación de aplicaciones y otorga sus listas de privilegios documentadas.
db_list_all_data_roles.sh Realiza una inspección de solo lectura de los roles de Deep Data Security, las asignaciones de IAM, los permisos de datos, los predicados, los objetos protegidos, los usuarios finales y las identidades de aplicaciones.

.deepsec.env solo lo utiliza la configuración de la base de datos. Incluye las contraseñas de administrador de seguridad y propietario de esquema. El proceso de Flask carga .deepsec.runtime.env y excluye intencionalmente ambas contraseñas con privilegios. No exporte el archivo de configuración al shell que inicia la aplicación web. Para utilizar diferentes rutas, defina OAM_DEEPSEC_ENV_FILE para la configuración o OAM_WEB_ENV_FILE para el proceso web.

Los valores importantes de IAM se asignan de la siguiente manera:

Variable del entorno Valor de OCI IAM
OAM_DEEPSEC_OCI_DB_APP_ID ID de aplicación de la aplicación Database
OAM_DEEPSEC_OCI_DB_CLIENT_ID ID de cliente de la aplicación Database
OAM_DEEPSEC_OCI_DB_CLIENT_SECRET Secreto de cliente de la aplicación de base de datos
OAM_WEB_OCI_CLIENT_ID ID de cliente de la aplicación web
OAM_WEB_OCI_CLIENT_SECRET Secreto de cliente de la aplicación web
OAM_WEB_OCI_END_USER_SCOPE OracleAgentMemoryWebAPP_ACCESS_SCOPE
OAM_WEB_OCI_DATABASE_ACCESS_SCOPE OracleDBDB_ACCESS_SCOPE

OAM_DEEPSEC_CONFIG_DIR solo es necesario cuando el DSN es un alias de TNS cuyo tnsnames.ora no se puede detectar de otro modo. La ubicación y la contraseña de la cartera son opcionales cuando sqlnet.ora y el DSN ya proporcionan todo lo que necesita python-oracledb. Para conocer las opciones de conexión de Autonomous AI Database, consulte Conexión de aplicaciones Python con una cartera.

Configure también un proveedor de incrustación. La aplicación solo muestra y agrega memorias, pero Agent Memory sigue creando incrustaciones cuando almacena contenido de memoria. La plantilla utiliza un modelo compatible con OpenAI como ejemplo; sustituya el modelo, la base de API, la clave y la dimensión por los valores de su proveedor.

Configurar las tres cuentas de base de datos

Advertencia: los comandos de esta sección cambian la configuración de autenticación externa de toda la base de datos y los privilegios de cuenta. Inspeccione primero los scripts. No las ejecute en una base de datos compartida o de producción.

Utilice tres usuarios de base de datos distintos:

Responsabilidad Cuenta de ejemplo Trabajo permitido
Administrador de seguridad ADMIN Activa la integración de OCI IAM y crea, otorga, revoca, muestra y elimina roles de datos y otorgamientos de datos. Nunca se utiliza para solicitudes web.
Propietario del esquema gestionado OAM_SCHEMA_OWNER Crea tablas, índices, procedimientos y trabajos del programador de memoria del agente. Solo se utiliza para operaciones de ciclo de vida de esquema.
Usuario de la BD de aplicación OAM_APP_DB_USER Abre sesiones y asocia contextos de seguridad de usuario final. No recibe ningún privilegio SELECT, INSERT, UPDATE ni DELETE ordinario.

Esta separación hace que se cierre una solicitud sin un fallo de contexto de usuario final válido. La guía de configuración de la base de datos de Oracle recomienda CREATE SESSION y CREATE END USER SECURITY CONTEXT para la cuenta de pool de conexiones; consulte Configuración de la base de datos para la integración de IAM.

En el ejemplo se utiliza la cuenta ADMIN de Autonomous AI Database para la configuración. Una cuenta de administrador de seguridad personalizada debe poder crear y modificar los dos usuarios de la base de datos y otorgar los privilegios del sistema enumerados. Puesto que las tablas de memoria del agente pertenecen a un esquema independiente, la administración de políticas necesita CREATE ANY DATA GRANT, DROP ANY DATA GRANT y ADMINISTER ANY DATA GRANT en lugar de solo CREATE DATA GRANT en el propio esquema del administrador. También debe estar autorizado para crear y borrar los roles de datos utilizados por las políticas.

Activar validación de token de OCI IAM

Revise y ejecute:

bash database_scripts/db_ociiam_setup.sh

La secuencia de comandos se conecta como administrador de seguridad y:

Solo puede haber un proveedor de identidad externo activo. El script de ejemplo utiliza force => TRUE para actualizar los parámetros de OCI IAM, lo que puede interrumpir otra configuración de autenticación externa. Oracle documenta las llamadas exactas a Autonomous Database en Configuración de la base de datos para la integración de IAM.

Crear el propietario y los usuarios del pool

Revise y ejecute:

bash database_scripts/db_deepsec_user_setup.sh

El script no cambia ADMIN. Crea usuarios de propietario y agrupación de aplicaciones y otorga:

-- Managed-schema owner
CREATE SESSION, CREATE TABLE, CREATE SEQUENCE,
CREATE VIEW, CREATE PROCEDURE, CREATE JOB

-- Runtime application pool
CREATE SESSION, CREATE END USER SECURITY CONTEXT

El propietario recibe la cuota en el tablespace DATA de Autonomous AI Database. El usuario del pool no recibe privilegios directos en las tablas del propietario. Para mantener el ejemplo centrado en las sentencias necesarias, la secuencia de comandos no comprueba los usuarios existentes ni inspecciona sus privilegios actuales. Utilice nuevos nombres de cuenta; el archivo de comandos se para si ya existe un usuario o si falla otra sentencia SQL.

Crear la política de tienda y de fila propia

Instale el entorno de ejemplo independiente:

uv sync

A continuación, ejecute el programa de configuración:

uv run python scripts/setup_memory.py

Este comando es intencionalmente destructivo solo para OAM_WEB_MEMORY_STORE_ID. Es:

  1. se conecta como propietario del esquema para volver a crear el esquema de memoria del agente;
  2. se conecta como administrador de seguridad para agregar la política de propia fila y otorgarla a ORACLEAGENTMEMORY_USERS.

Las llamadas de administración de agregar y otorgar son idempotentes. Volver a ejecutarlas sustituye las mismas definiciones y asignaciones de políticas gestionadas y reintentar reparaciones de DDL parcialmente gestionado dejadas por un intento interrumpido.

La política crea un rol de datos asignado externamente para el grupo de OCI IAM y los otorgamientos de datos cuyo predicado de fila compara los valores user_id almacenados con ORA_END_USER_CONTEXT.username. Oracle documenta la sintaxis de asignación en CREATE DATA ROLE y la autorización de filas en CREATE DATA Grants.

Inspeccione el resultado:

bash database_scripts/db_list_all_data_roles.sh

Debe ver el rol asignado a IAM, los permisos de datos de memoria del agente y sus tablas de esquema de propietario protegidas. Este script de inspección solo consulta vistas de catálogo; no crea, modifica ni elimina objetos de Deep Data Security.

Utilizar un modelo de incrustación en la base de datos con Deep Sec

Esta sección se aplica cuando la aplicación utiliza OracleDBEmbedder con el valor por defecto provider="database" y un modelo de embebido almacenado en Oracle AI Database, normalmente un modelo ONNX importado como DMUSER.DOC_MODEL. En esta configuración, la incrustación directa utiliza el operador SQL VECTOR_EMBEDDING de Oracle, por lo que el modelo necesita el privilegio SELECT ON MINING MODEL que se describe a continuación.

OracleDBEmbedder también admite proveedores remotos mediante DBMS_VECTOR_CHAIN.UTL_TO_EMBEDDING, por ejemplo, con provider="openai". Esas configuraciones siguen llamando a la solicitud de embebido de Oracle AI Database, pero no acceden a un modelo de minería que reside en la base de datos; las instrucciones SELECT ON MINING MODEL de esta sección no se aplican. Las operaciones de memoria del agente se deben seguir ejecutando dentro de OracleMemoryEndUserSecurityContext.

Una política de memoria de agente otorga acceso a las tablas de memoria de agente. No otorga acceso a un modelo de integración de Oracle AI Database. El modelo necesita su propio privilegio de base de datos: SELECT ON MINING MODEL.

No otorgue ese privilegio al usuario de agrupación de aplicaciones. Durante una solicitud, Deep Sec autoriza al usuario a través del rol de datos asignado desde el grupo de OCI IAM, no a través de los privilegios normales del usuario del pool. Por lo tanto, un privilegio otorgado sólo al usuario de la agrupación no está disponible mientras un contexto de seguridad de usuario final está activo.

Cree un rol de datos asignado para cada grupo de IAM que necesite utilizar el modelo. Asigne a ese rol de datos un rol de base de datos normal que tenga acceso al modelo. Ejecute el siguiente SQL como administrador de seguridad de la base de datos u otra cuenta autorizada para crear roles y otorgar acceso al modelo. Sustituya los nombres de ejemplo por nombres para la aplicación:

-- This must exactly match the OCI IAM group passed to OciGroupPrincipal.
CREATE DATA ROLE APP_MEMORY_USERS_DATA_ROLE
  MAPPED TO 'IAM_OAUTH_GROUP=YOUR_IAM_GROUP';

-- This ordinary database role carries access to one embedding model.
CREATE ROLE APP_DOC_MODEL_ROLE;

GRANT SELECT ON MINING MODEL YOUR_USER.DOC_MODEL
  TO APP_DOC_MODEL_ROLE;

-- Give model access to the IAM group's Deep Sec data role.
GRANT APP_DOC_MODEL_ROLE TO APP_MEMORY_USERS_DATA_ROLE;

A continuación, la aplicación utiliza el mismo nombre de grupo cuando otorga políticas de memoria del agente:

grant_agent_memory_policies(
    admin_connection,
    owner_schema="OAM_SCHEMA_OWNER",
    memory_store_id="MEMORY",
    principals=[OciGroupPrincipal("YOUR_IAM_GROUP")],
    policies=[UserOwnRowsDeepDataSecurityPolicy()],
)

grant_agent_memory_policies() busca el rol existente asignado a YOUR_IAM_GROUP y agrega los permisos de datos de la tabla de memoria del agente a ese mismo rol. No crea un segundo rol. En tiempo de ejecución, un usuario cuyo token de OCI IAM contenga YOUR_IAM_GROUP puede acceder a las filas de memoria de agente permitidas y a DMUSER.DOC_MODEL.

Si la aplicación ya llamó a grant_agent_memory_policies() antes de la configuración de este modelo, la memoria del agente ya ha creado el rol de datos asignado. No cree otro rol asignado para el mismo grupo. Encontrar el rol existente y otorgarle el rol de modelo ordinario en su lugar:

SELECT data_role
FROM sys.dba_data_roles
WHERE UPPER(mapped_to) = UPPER('IAM_OAUTH_GROUP=YOUR_IAM_GROUP');

GRANT APP_DOC_MODEL_ROLE TO <DATA_ROLE_RETURNED_BY_THE_QUERY>;

Mantenga todas las operaciones OracleDBEmbedder de tiempo de ejecución dentro de OracleMemoryEndUserSecurityContext. No utilice el propietario del esquema, una conexión de administrador independiente o una conexión sin un contexto de seguridad de usuario final para ejecutar incrustaciones para una solicitud de usuario. Esto omitiría el límite de autorización de Deep Sec.

Comprender la aplicación

El proyecto descargable, deepsec_oci_iam_webapp.zip, contiene los scripts completos de base de datos y aplicación web. Las partes clave de la aplicación son deliberadamente pequeñas.

Iniciar y finalizar OAuth

La ruta de inicio de sesión crea valores state y PKCE aleatorios. Solo el ID de sesión opaco se coloca en una cookie HttpOnly, SameSite=Lax; los tokens permanecen en el almacén de sesiones de demostración local de proceso.

def start_authorization(config: RuntimeConfig) -> AuthorizationRequest:
    """Build a state-bound Authorization Code request with PKCE."""
    state = secrets.token_urlsafe(32)
    code_verifier = secrets.token_urlsafe(64)
    challenge = (
        base64.urlsafe_b64encode(hashlib.sha256(code_verifier.encode()).digest())
        .rstrip(b"=")
        .decode("ascii")
    )
    query = urllib.parse.urlencode(
        {
            "client_id": config.oauth_client_id,
            "response_type": "code",
            "redirect_uri": config.redirect_uri,
            "scope": config.end_user_scope,
            "state": state,
            "code_challenge": challenge,
            "code_challenge_method": "S256",
        }
    )
    return AuthorizationRequest(
        url=f"{config.domain_url}/oauth2/v1/authorize?{query}",
        state=state,
        code_verifier=code_verifier,
    )


def exchange_authorization_code(
    config: RuntimeConfig,
    code: str,
    code_verifier: str,
) -> EndUserToken:
    """Exchange one browser authorization code for an end-user token."""
    payload = _token_request(
        config,
        {
            "grant_type": "authorization_code",
            "code": code,
            "redirect_uri": config.redirect_uri,
            "code_verifier": code_verifier,
        },
    )
    access_token, expires_at = _required_access_token(payload)
    return EndUserToken(
        access_token=access_token,
        username=_display_username(access_token),
        expires_at=expires_at,
    )

La devolución de llamada compara state en tiempo constante e intercambia el código con el mismo URI de redirección y el verificador PKCE. La aplicación obtiene por separado un token de acceso a la base de datos:

    def get(self, config: RuntimeConfig) -> str:
        """Return a current database-access token."""
        with self._lock:
            if self._token is not None and time.time() < self._expires_at - 60:
                return self._token
            payload = _token_request(
                config,
                {
                    "grant_type": "client_credentials",
                    "scope": config.database_access_scope,
                },
            )
            self._token, self._expires_at = _required_access_token(payload)
            return self._token

OCI IAM documenta ambas solicitudes de token en Validación de la configuración de OCI IAM.

Alcance cada operación de memoria de agente

La aplicación combina ambos tokens en un contexto de seguridad de usuario final python-oracledb. A continuación, examina cada inicialización y operación del almacén con OracleMemoryEndUserSecurityContext:

def list_visible_memories(
    config: RuntimeConfig,
    pool: Any,
    user_context: Any,
) -> list[Any]:
    """List rows visible to the effective OCI IAM end user."""
    with OracleMemoryEndUserSecurityContext(user_context):
        store = create_runtime_store(config, pool)
        return store.list("memory", limit=100)


def add_memory(
    config: RuntimeConfig,
    pool: Any,
    user_context: Any,
    content: str,
    target_username: str,
) -> None:
    """Attempt to insert a row for the username supplied by the browser."""
    with OracleMemoryEndUserSecurityContext(user_context):
        store = create_runtime_store(config, pool)
        store.add(
            contents=[content],
            record_type="memory",
            user_ids=[target_username],
        )

El almacén de tiempo de ejecución utiliza SchemaPolicy.NO_CHECK porque la creación, validación, actualizaciones y recreación del esquema pertenecen a la ruta de configuración del propietario del esquema. El SDK rechaza otra política de esquema mientras el contexto del usuario final está activo y rechaza las operaciones posteriores en este almacén de tiempo de ejecución protegido cuando no hay ningún contexto activo. Las funciones de administración de seguridad también rechazan las conexiones que llevan un contexto de usuario final.

Para cada operación de base de datos de memoria del agente, el gestor de contexto:

La cuenta de base de datos del pool no tiene privilegios de tabla de reserva. La API de carga útil de python-oracledb se documenta en Creación de carga útil de contexto de seguridad de usuario final. En la API de seguridad de datos profunda y referencia de seguridad se explica el contrato completo del mánager de contexto.

Deje que la base de datos decida

La ruta reenvía el nombre de usuario enviado sin cambios. Captura y desinfecta los errores de la base de datos, pero no contiene ninguna rama de autorización username == signed_in_user:

@web.route("/", methods=["GET", "POST"])
def index() -> Response | tuple[str, int]:
    """Show visible memories and let the user attempt one insert."""
    config, pool, _ = _extensions()
    _, session = _session()
    if session is None or session.end_user_token is None:
        return render_template("index.html", session=None, memories=[])

    message = None
    status = 200
    try:
        user_context = _security_context(config, session)
        if request.method == "POST":
            if not hmac.compare_digest(
                request.form.get("csrf_token", ""),
                session.csrf_token,
            ):
                return render_template("error.html", message="The form expired."), 400
            content = request.form.get("content", "").strip()
            target_username = request.form.get("username", "").strip()
            if not content or not target_username:
                message = "Content and username are required."
                status = 400
            elif len(content) > 4000 or len(target_username) > 255:
                message = "The submitted memory is too large."
                status = 400
            else:
                try:
                    add_memory(
                        config,
                        pool,
                        user_context,
                        content,
                        target_username,
                    )
                    message = "Memory added."
                except oracledb.DatabaseError:
                    #Keep listing permitted rows after the deliberately denied write.
                    message = "Oracle AI Database denied this operation for the effective end user."
                    status = 403

        memories = list_visible_memories(config, pool, user_context)
    except oracledb.DatabaseError:
        #Never expose raw database errors, token contents, or submitted values.
        message = "Oracle AI Database denied this operation for the effective end user."
        memories = []
        status = 403
    except OAuthError:
        message = "The login session expired. Sign in again."
        memories = []
        status = 401

    return (
        render_template(
            "index.html",
            session=session,
            memories=memories,
            message=message,
        ),
        status,
    )

Jinja escapa del contenido de memoria mostrado. Las excepciones de la base de datos raw, las respuestas de OAuth, los tokens y los valores enviados nunca se representan.

Ejecutar y verificar la aplicación

Inicie el servidor de desarrollo de Flask:

uv run python run.py

Abra http://127.0.0.1:8000.

Verifique el límite de autorización:

  1. Inicie sesión como Alice.
  2. Agregue Alice's first memory con el nombre de usuario rellenado previamente alice.
  3. Confirme que la memoria aparezca en Visible memory.
  4. Agregue Alice tries to write for Bob pero cambie el nombre de usuario a bob.
  5. Confirme que Oracle AI Database deniega la operación.
  6. Cierre sesión, inicie sesión como Bob y confirme que la memoria de Alice no está visible.
  7. Agregue una memoria como Bob, vuelva a iniciar sesión como Alice y confirme que la memoria de Bob no está visible.

Esto demuestra dos controles independientes:

Para las operaciones de producción, configure Oracle Unified Auditing para las acciones de contexto de seguridad de usuario final y administración de Deep Sec que su organización debe conservar. También tenga en cuenta el contrato de tiempo de revocación documentado: la revocación de la política de SDK se confirma antes de que se devuelva la llamada de administración, mientras que la eliminación de un usuario de un grupo de OCI IAM no reescribe un token de acceso ya emitido. Consulte Seguridad de datos profunda para obtener orientación sobre auditoría, comportamiento de caducidad de token y enlaces a la documentación correspondiente de Oracle Deep Sec y OCI IAM.

Si la conexión se realiza correctamente, pero la base de datos deniega cada operación, inspeccione el token de usuario final y verifique que group contiene ORACLEAGENTMEMORY_USERS. La resolución de problemas de privilegios y acceso de seguridad de datos profunda de Oracle también describe cómo un administrador puede inspeccionar los roles de datos activos.

Lo que la producción aún requiere

Advertencia: completar esta guía no hace que el ejemplo esté listo para la producción.

Antes de adaptar el diseño, sustituya o agregue al menos:

Mantenga el núcleo invariante: la cuenta de pool de tiempo de ejecución no tiene privilegios DML de tabla directa y cada solicitud de memoria de agente se ejecuta dentro de un OracleMemoryEndUserSecurityContext verificado.