Imponha o isolamento de memória do usuário final com Deep Data Security

Este guia mostra como impor o isolamento do usuário final para um aplicativo Oracle AI Agent Memory com o OCI IAM e o Oracle Deep Data Security.

Aviso: Somente ambiente de aprendizagem. Não implante este exemplo na produção.

O aplicativo usa o servidor de desenvolvimento do Flask, um armazenamento de sessão na memória, segredos de arquivo de ambiente e tratamento simplificado do ciclo de vida do token. Os scripts de configuração do banco de dados modificam as definições e os privilégios do provedor de identidade em todo o banco de dados. Use apenas usuários descartáveis e um Oracle Autonomous AI Database isolado e não relacionado à produção.

Este guia cria um aplicativo web deliberadamente pequeno:

A rota não compara Alice e o próprio Bob. Ele passa o token do usuário final para o Oracle AI Database, onde o Oracle Deep Data Security impõe a política de linha própria do Agent Memory.

Este guia demonstra uma implantação. Para obter o recurso de segurança completo, incluindo todas as políticas, principais, função de administração, API de contexto de runtime, auditoria e tempo de revogação suportados, consulte a Referência de segurança e API de Segurança de Dados Profunda.

Neste guia, você irá:

Entenda a cadeia de confiança

O browser e o aplicativo usam dois tokens de acesso OAuth diferentes:

  1. O token do usuário final identifica Alice ou Bob e inclui os grupos do IAM do usuário.
  2. O token database-access, obtido pelo aplicativo confidencial por meio de Credenciais do Cliente, prova que o aplicativo pode acessar o recurso do banco de dados.

O Oracle AI Database valida os dois tokens antes de anexar o contexto de segurança do usuário final.

A Oracle documenta esse modelo de dois tokens em Entender Fluxo de Autenticação e Pré-requisitos e o ciclo de vida completo em Contexto de Segurança do Usuário Final.

Pré-requisitos

Você precisa:

O Oracle Deep Data Security é uma autorização detalhada imposta pelo banco de dados. Consulte O que é Oracle Deep Data Security.

Configurar o domínio de identidades do OCI IAM

Faça todo o trabalho do OCI IAM em um domínio de identidades. Registre seu URL de Domínio, por exemplo, https://idcs-<id>.identity.oraclecloud.com:443.

O passo a passo autorizado da Oracle é Configurar o OCI IAM para Acesso Mediado por Aplicativos. Os valores no exemplo a seguir correspondem ao arquivo de ambiente de exemplo fornecido com este guia.

Registrar o recurso de banco de dados

Em Domínio de identidades > Aplicativos integrados:

  1. Adicione um Aplicativo Confidencial chamado OracleDB.
  2. Configure-o como um servidor de recursos:
    • Público-alvo principal: OracleDB
    • Escopo: DB_ACCESS_SCOPE
  3. Configure-o como um cliente e permita Credenciais do Cliente.
  4. Ative-a.
  5. Registre seu ID do Aplicativo, seu ID do Cliente e seu Segredo do cliente.

O escopo do banco de dados totalmente qualificado é o público concatenado com o nome do escopo:

OracleDBDB_ACCESS_SCOPE

Siga Registrar o Banco de Dados no OCI IAM para obter os labels da Console e as descrições de campo atuais.

Registrar o aplicativo web

Adicione um segundo Aplicativo Confidencial chamado OracleAgentMemoryWeb:

  1. Ative Impor concessões como autorização.
  2. Configure-o como um servidor de recursos:
    • Público-alvo principal: OracleAgentMemoryWeb
    • Escopo: APP_ACCESS_SCOPE
    • Vida útil do token de acesso: 3600 segundos para este exercício
  3. Configure-o como um cliente com estas concessões:
    • Código de Autorização
    • Credenciais do Cliente
  4. Adicione esta URL de redirecionamento exata: 
    http://127.0.0.1:8000/auth/callback
  5. Em recursos do cliente, conceda acesso a ambos:
    • OracleDBDB_ACCESS_SCOPE
    • OracleAgentMemoryWebAPP_ACCESS_SCOPE
  6. Ative o aplicativo e registre seu ID do Cliente e seu Segredo do cliente.

O aplicativo usa o Código de Autorização com state e PKCE S256. O OCI IAM documenta a configuração de cliente necessária em Registrar o Aplicativo no OCI IAM e fornece um exemplo de Código de Autorização PKCE.

Adicionar a reivindicação do grupo

O Oracle AI Database ativa atribuições de dados mapeadas externamente da reivindicação group do token do usuário final. As reivindicações personalizadas do OCI IAM são configuradas por meio da API REST de domínio de identidades, não da Console.

Como Administrador de Domínio de Identidades, faça download de um token de acesso pessoal de curta duração que possa chamar APIs de domínio de identidades. Depois, execute:

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
  }'

Uma solicitação bem-sucedida retorna HTTP 201. Não crie uma duplicata se o domínio já tiver essa reivindicação. Consulte Configurar Reivindicações Personalizadas para Informações de Grupo no OCI IAM.

Criar Alice, Bob e o grupo de aplicativos

  1. Crie um grupo chamado ORACLEAGENTMEMORY_USERS.
  2. Crie usuários de teste alice e bob.
  3. Atribua ambos os usuários a ORACLEAGENTMEMORY_USERS.
  4. Atribua o grupo a OracleAgentMemoryWeb.

Posteriormente, o banco de dados mapeará esse nome de grupo para uma atribuição de dados. Os nomes de grupo são comparados sem distinção entre maiúsculas e minúsculas, mas usam a mesma grafia em toda a configuração. Consulte Criar Usuários e Designar Grupos no OCI IAM.

Preparar o ambiente

Faça download do aplicativo Web completo, deepsec_oci_iam_webapp.zip. O arquivo também contém scripts de inspeção e configuração de banco de dados independentes pertencentes a este exemplo. Eles não importam nem empacotam scripts do conjunto de testes do SDK.

Extraia o arquivo compactado, informe seu diretório de projeto e crie arquivos de ambiente de configuração e tempo de execução locais:

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))"

Coloque o valor gerado em OAM_WEB_SECRET_KEY e preencha cada espaço reservado necessário em ambos os arquivos. Ambos os nomes de arquivos são ignorados pelo Git.

O diretório database_scripts contém:

Arquivo Responsabilidade
_common.sh O auxiliar privado que carrega .deepsec.env, valida valores obrigatórios, verifica o SQL*Plus e exporta TNS_ADMIN quando configurado. Não os execute diretamente.
db_ociiam_setup.sh Ativa a autenticação externa do OCI IAM para o Autonomous AI Database de destino e substitui o OCI_IAM_DOMAIN_DB_CRED$.
db_deepsec_user_setup.sh Cria o proprietário do esquema e os usuários do pool de aplicativos e concede suas listas de permissões de privilégios documentados.
db_list_all_data_roles.sh Executa inspeção somente leitura de atribuições de Segurança de Dados Profunda, mapeamentos do IAM, concessões de dados, predicados, objetos protegidos, usuários finais e identidades de aplicativos.

.deepsec.env é usado somente pela configuração do banco de dados. Inclui as senhas do administrador de segurança e do proprietário do esquema. .deepsec.runtime.env é carregado pelo processo do Flask e exclui intencionalmente ambas as senhas privilegiadas. Não exporte o arquivo de configuração para o shell que inicia o aplicativo Web. Para usar caminhos diferentes, defina OAM_DEEPSEC_ENV_FILE para configuração ou OAM_WEB_ENV_FILE para o processo Web.

Os valores importantes do IAM são mapeados da seguinte forma:

Variável do ambiente Valor do OCI IAM
OAM_DEEPSEC_OCI_DB_APP_ID ID do Aplicativo do aplicativo de banco de dados
OAM_DEEPSEC_OCI_DB_CLIENT_ID ID do Cliente do aplicativo de banco de dados
OAM_DEEPSEC_OCI_DB_CLIENT_SECRET Segredo do cliente do aplicativo de banco de dados
OAM_WEB_OCI_CLIENT_ID ID do Cliente do aplicativo Web
OAM_WEB_OCI_CLIENT_SECRET Segredo do cliente do aplicativo Web
OAM_WEB_OCI_END_USER_SCOPE OracleAgentMemoryWebAPP_ACCESS_SCOPE
OAM_WEB_OCI_DATABASE_ACCESS_SCOPE OracleDBDB_ACCESS_SCOPE

OAM_DEEPSEC_CONFIG_DIR é necessário somente quando o DSN é um alias TNS cujo tnsnames.ora não é detectável. A localização e a senha da wallet são opcionais quando sqlnet.ora e o DSN já fornecem tudo o que o python-oracledb precisa. Para obter opções de conexão do Autonomous AI Database, consulte Connect Python Applications with a Wallet.

Configure também um profissional de saúde de incorporação. O aplicativo apenas lista e adiciona memórias, mas a Memória do Agente ainda cria incorporações quando armazena o conteúdo da memória. O modelo usa um modelo compatível com OpenAI como exemplo; substitua o modelo, a base da API, a chave e a dimensão pelos valores do seu provedor.

Configurar as três contas de banco de dados

Aviso: Os comandos desta seção alteram as definições de autenticação externa e os privilégios de conta em todo o banco de dados. Inspecione os scripts primeiro. Não execute-os em um banco de dados compartilhado ou de produção.

Use três usuários distintos de banco de dados:

Responsabilidade Exemplo de conta Trabalho permitido
Administrador de segurança ADMIN Permite a integração do OCI IAM e cria, concede, revoga, lista e remove atribuições de dados e concessões de dados. Nunca é usado para solicitações da web.
Proprietário do esquema gerenciado OAM_SCHEMA_OWNER Cria tabelas de Memória do Agente, índices, procedimentos e jobs do scheduler. Ele é usado apenas para operações do ciclo de vida do esquema.
Usuário do Banco de Dados do Aplicativo OAM_APP_DB_USER Abre sessões e anexa contextos de segurança do usuário final. Ele não recebe privilégios SELECT, INSERT, UPDATE ou DELETE comuns.

Esta separação faz uma solicitação sem que um contexto de usuário final válido falhe fechado. O guia de configuração do banco de dados da Oracle recomenda CREATE SESSION e CREATE END USER SECURITY CONTEXT para a conta do pool de conexões; consulte Configurar o Banco de Dados para Integração do Serviço IAM.

O exemplo usa a conta ADMIN do Autonomous AI Database para configuração. Uma conta personalizada de administrador de segurança deve ser capaz de criar e alterar os dois usuários do banco de dados e conceder seus privilégios de sistema listados. Como as tabelas da Memória do Agente pertencem a um esquema separado, a administração de políticas requer CREATE ANY DATA GRANT, DROP ANY DATA GRANT e ADMINISTER ANY DATA GRANT, em vez de apenas CREATE DATA GRANT no próprio esquema do administrador. Ele também deve estar autorizado a criar e eliminar as atribuições de dados usadas pelas políticas.

Ativar validação de token do OCI IAM

Revise e execute:

bash database_scripts/db_ociiam_setup.sh

O script se conecta como o administrador de segurança e:

Somente um provedor de identidades externo pode estar ativo. O exemplo de script usa force => TRUE para atualizar os parâmetros do OCI IAM, que podem interromper outra configuração de autenticação externa. O sistema Oracle documenta as chamadas exatas do Autonomous Database em Configurar o Banco de Dados para Integração do Serviço IAM.

Criar o proprietário e os usuários do pool

Revise e execute:

bash database_scripts/db_deepsec_user_setup.sh

O script não altera ADMIN. Ele cria o proprietário e os usuários do pool de aplicativos e concede:

-- 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

O proprietário recebe cota no tablespace DATA do Autonomous AI Database. O usuário do pool não recebe privilégios diretos nas tabelas do proprietário. Para manter o exemplo focado nas instruções necessárias, o script não verifica usuários existentes nem inspeciona seus privilégios atuais. Use novos nomes de conta; o script será interrompido se o usuário já existir ou outra instrução SQL falhar.

Criar a política de armazenamento e de linha própria

Instale o ambiente de exemplo independente:

uv sync

Em seguida, execute o programa de definição:

uv run python scripts/setup_memory.py

Este comando só é intencionalmente destrutivo para OAM_WEB_MEMORY_STORE_ID. Ele:

  1. se conecta como proprietário do esquema para recriar o esquema da Memória do Agente;
  2. se conecta como administrador de segurança para adicionar a política de linha própria e concedê-la a ORACLEAGENTMEMORY_USERS.

As chamadas de administração de adição e concessão são idempotentes. A reexecução deles substitui as mesmas definições e designações de política gerenciadas e a repetição repara a DDL gerenciada parcial deixada por uma tentativa interrompida.

A política cria uma atribuição de dados mapeada externamente para o grupo do OCI IAM e concessões de dados cujo predicado de linha compara valores user_id armazenados com ORA_END_USER_CONTEXT.username. O sistema Oracle documenta a sintaxe de mapeamento em CREATE DATA ROLE e autorização de linha em CREATE DATA Grants.

Inspecione o resultado:

bash database_scripts/db_list_all_data_roles.sh

Você deverá ver a atribuição mapeada pelo IAM, as concessões de dados de Memória do Agente e suas tabelas protegidas de esquema do proprietário. Este script de inspeção consulta apenas as exibições do catálogo; ele não cria, altera nem remove objetos de Segurança de Dados Profundos.

Use um modelo de incorporação no banco de dados com Deep Sec

Esta seção se aplica quando o aplicativo usa OracleDBEmbedder com o provider="database" padrão e um modelo de incorporação armazenado no Oracle AI Database, geralmente um modelo ONNX importado, como DMUSER.DOC_MODEL. Nesta configuração, a incorporação direta usa o operador SQL VECTOR_EMBEDDING da Oracle, de modo que o modelo requer o privilégio SELECT ON MINING MODEL descrito abaixo.

O OracleDBEmbedder também suporta provedores remotos por meio do DBMS_VECTOR_CHAIN.UTL_TO_EMBEDDING, por exemplo, com provider="openai". Essas configurações ainda chamam a solicitação de incorporação do Oracle AI Database, mas não acessam um modelo de mineração residente no banco de dados; as instruções SELECT ON MINING MODEL nesta seção não se aplicam. As operações de Memória do Agente ainda devem ser executadas em um OracleMemoryEndUserSecurityContext.

Uma política de Memória do Agente concede acesso às tabelas de Memória do Agente. Ele não concede acesso a um modelo de incorporação do Oracle AI Database. O modelo precisa de seu próprio privilégio de banco de dados: SELECT ON MINING MODEL.

Não conceda esse privilégio ao usuário do pool de aplicativos. Durante uma solicitação, a Deep Sec autoriza o usuário por meio da atribuição de dados mapeada do grupo do OCI IAM, não por meio dos privilégios normais do usuário do pool. Portanto, um privilégio concedido apenas ao usuário do pool está indisponível enquanto um contexto de segurança de usuário final está ativo.

Crie uma atribuição de dados mapeada para cada grupo do IAM que precise usar o modelo. Atribua a essa atribuição de dados uma atribuição de banco de dados normal que tenha acesso ao modelo. Execute o SQL a seguir como administrador de segurança do banco de dados ou outra conta autorizada a criar atribuições e conceder acesso ao modelo. Substitua os nomes de exemplo pelos nomes de seu aplicativo:

-- 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;

Em seguida, o aplicativo usa o mesmo nome de grupo quando concede políticas de Memória do 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() localiza a atribuição existente mapeada para YOUR_IAM_GROUP e adiciona as concessões de dados da tabela Memória do Agente a essa mesma atribuição. Ele não cria uma segunda atribuição. No runtime, um usuário cujo token do OCI IAM contenha YOUR_IAM_GROUP pode acessar as linhas permitidas da Memória do Agente e DMUSER.DOC_MODEL.

Se o aplicativo já tiver chamado grant_agent_memory_policies() antes da configuração deste modelo, a Memória do Agente já terá criado a atribuição de dados mapeados. Não crie outra função mapeada para o mesmo grupo. Localize a atribuição existente e conceda a atribuição de modelo comum a ela:

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>;

Mantenha cada operação de runtime OracleDBEmbedder dentro de OracleMemoryEndUserSecurityContext. Não use o proprietário do esquema, uma conexão de administrador separada ou uma conexão sem um contexto de segurança de usuário final para executar incorporações para uma solicitação de usuário. Isso contornaria o limite de autorização da Deep Sec.

Compreender o aplicativo

O projeto para download, deepsec_oci_iam_webapp.zip, contém o aplicativo web completo e scripts de banco de dados. As principais peças de aplicação são deliberadamente pequenas.

Iniciar e concluir OAuth

A rota de log-in cria valores aleatórios state e PKCE. Somente o ID da sessão opaca é colocado em um cookie HttpOnly, SameSite=Lax; os tokens permanecem no armazenamento da sessão de demonstração process-local.

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,
    )

O callback compara state em tempo constante e troca o código com o mesmo URI de redirecionamento e verificador PKCE. O aplicativo obtém separadamente um token de acesso ao banco de dados:

    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

O OCI IAM documenta as duas solicitações de token em Validar a Configuração do OCI IAM.

Escopo de cada operação de Memória do Agente

O aplicativo combina ambos os tokens em um contexto de segurança de usuário final python-oracledb. Em seguida, ele faz o escopo de cada inicialização e operação de armazenamento com 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],
        )

O armazenamento de runtime usa SchemaPolicy.NO_CHECK porque a criação, validação, upgrades e recriação do esquema pertencem ao caminho de configuração do proprietário do esquema. O SDK rejeita outra política de esquema enquanto o contexto do usuário final está ativo e rejeita operações posteriores neste armazenamento de runtime protegido quando nenhum contexto está ativo. As funções de administração de segurança também rejeitam conexões que carregam um contexto de usuário final.

Para cada operação do banco de dados de Memória do Agente, o gerenciador de contexto:

A conta de banco de dados do pool não tem privilégios de tabela de fallback. A API de carga útil de python-oracledb está documentada em Criação de Carga Útil de Contexto de Segurança do Usuário Final. A Referência de segurança e API de Segurança de Dados Profundos explica o contrato completo do gerente de contexto.

Deixe o banco de dados decidir

A rota encaminha o nome de usuário enviado inalterado. Ele captura e higieniza erros de banco de dados, mas não contém ramificação de autorização 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 do conteúdo de memória exibido. Exceções de banco de dados bruto, respostas OAuth, tokens e valores enviados nunca são renderizados.

Executar e verificar o aplicativo

Inicie o servidor de desenvolvimento Flask:

uv run python run.py

Abra http://127.0.0.1:8000.

Verifique o limite de autorização:

  1. Entre como Alice.
  2. Adicione Alice's first memory com o nome de usuário preenchido alice.
  3. Confirme se a memória aparece em Memórias visíveis.
  4. Adicione Alice tries to write for Bob, mas altere o nome de usuário para bob.
  5. Confirme se o Oracle AI Database nega a operação.
  6. Desconecte-se, entre como Bob e confirme que a memória de Alice não está visível.
  7. Adicione uma memória como Bob, entre novamente como Alice e confirme que a memória de Bob não está visível.

Isso demonstra dois controles independentes:

Para operações de produção, configure o Oracle Unified Auditing para a administração de Deep Sec e as ações de contexto de segurança do usuário final que sua organização deve manter. Considere também o contrato de tempo de revogação documentado: a revogação da política do SDK é confirmada antes do retorno da chamada de administração, enquanto a remoção de um usuário de um grupo do OCI IAM não reescreve um token de acesso já emitido. Consulte Deep Data Security para obter orientação de auditoria, comportamento de expiração de token e links para a documentação correspondente do Oracle Deep Sec e do OCI IAM.

Se o log-in for bem-sucedido, mas o banco de dados negar todas as operações, inspecione o token do usuário final e verifique se group contém ORACLEAGENTMEMORY_USERS. A Solução de problemas de privilégios e acesso de Segurança de Dados Profundos da Oracle também descreve como um administrador pode inspecionar atribuições de dados ativas.

O que a produção ainda requer

Aviso: a conclusão deste guia não torna o exemplo pronto para produção.

Antes de adaptar o projeto, substitua ou adicione pelo menos:

Mantenha a constante principal: a conta do pool de runtime não tem privilégios diretos de DML da tabela, e cada solicitação de Memória do Agente é executada dentro de um OracleMemoryEndUserSecurityContext verificado.