Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Importante
Esse recurso está em Beta. Administradores de workspace podem controlar o acesso a esse recurso a partir da página de Pré-visualizações, optando pela prévia Unity Gateway Service Policies. Consulte Gerenciar visualizações no nível do espaço de trabalho.
Uma política de serviço Python personalizada é uma função Python registrada no Catálogo Unity que decide se cada solicitação ou resposta a um serviço de IA é permitida. Use Python quando uma regra for difícil de expressar em SQL, quando ela precisa de uma biblioteca Python ou quando precisa chamar outro serviço, como um serviço guardrail que você já utiliza.
Anexe uma política do Python a um Serviço de Modelo, Serviço de Provedor de Modelo ou Serviço MCP, da mesma forma que anexa qualquer política de serviço.
Quando usar uma política Python
Escolha o tipo de política mais simples que expresse sua regra:
- Uma proteção integrada cobre riscos comuns, como conteúdo inseguro e dados sensíveis, sem código.
- Uma política personalizada de LLM como juiz trata de regras semânticas que você pode descrever em linguagem simples.
- Uma política SQL personalizada lida com verificações determinísticas simples em campos como o nome da ferramenta ou a identidade do chamador.
- Uma política de serviço externo aplica restrições por meio de um fornecedor de guardrail que implementa a API de política externa do Azure Databricks.
Use uma política Python para lógica que os outros tipos não conseguem expressar. Os usos comuns incluem:
- Filtragem de palavras-chave e padrões: bloqueie solicitações ou respostas que correspondam a expressões regulares, como nomes de host internos, IDs de tickets ou formatos de credenciais.
- Verificações personalizadas de dados sensíveis: detectam identificadores específicos da sua organização, como números de funcionários ou clientes, que a política de Detecção de Dados Sensíveis incorporada não cobre.
- Validação de argumentos de ferramentas: verifique em detalhes os argumentos de chamada de ferramenta MCP, por exemplo, para permitir uma gravação apenas em repositórios ou caminhos aprovados.
- Pacotes Python: use um pacote do PyPI, como um parser ou um classificador. Veja Adicionar pacotes Python.
- Chamadas para um guardrail parceiro ou serviço interno: chame um serviço externo, como um guardrail, com credencial de serviço do Unity Catalog e, em seguida, retorne seu veredito. Veja Chamar um serviço externo com credencial de serviço.
Availability
Políticas de serviço Python personalizadas estão disponíveis nas seguintes regiões:
eastuseastus2centraluswesteurope
Políticas de serviço Python personalizadas não estão disponíveis em outras regiões.
Como funciona uma política de Python
Uma política Python é um UDF Python do Catálogo Unity com assinatura fixa. Ele toma dois VARIANT parâmetros e retorna um VARIANT:
CREATE OR REPLACE FUNCTION <catalog>.<schema>.<function_name>(
event VARIANT,
config VARIANT
)
RETURNS VARIANT
LANGUAGE PYTHON
ENVIRONMENT (environment_version = '6')
AS $$
<function body>
$$;
-
eventé a interação sob avaliação. Ele possui os mesmos campos que o evento que uma política SQL recebe, comocontext.message(context.tool.nameoucontext.tool.arguments),context.actor(a mensagem mais recente do usuário ou assistente),responseerequestem um Serviço MCP, e a identidade do chamador emtype. Consulte campos do evento. -
configcontém quaisquer opções extras que você definisse no anexo através da API, como strings, excetodry_runemax_turns. A interface não define nenhuma, entãoconfiggeralmente é um objeto vazio. Sua função deve declará-la, mesmo que não a utilize. - A função retorna uma decisão:
ALLOW,ASKoureason, com umDENYopcional.ASKmantém uma chamada de ferramenta MCP para aprovação humana na fase de entrada. Em um resultado de uma ferramenta MCP,ASKdeixa o resultado passar, então volteDENYpara bloqueá-lo. Em um Serviço Modelo ou Serviço Provedor de Modelo,ASKbloqueia a interação, e o chamador vê uma mensagem queASKnão é suportada em vez do seureason, portanto retorneDENYpara lá.
O Azure Databricks executa a função em computação serverless que ele gerencia, não no seu warehouse ou cluster SQL. A função roda em ambos os pontos de avaliação, a solicitação (entrada) e a resposta (saída), então crie uma ramificação com base em type para agir em uma das fases. Se a função gerar um erro, expirar o tempo limite ou retornar uma decisão não reconhecida, o Azure Databricks nega a interação.
Antes de começar
- A prévia das Políticas de Serviço do Unity Gateway deve estar ativada para seu espaço de trabalho. Um administrador do espaço de trabalho ativa isso na página Pré-visualizações. Consulte Gerenciar pré-visualizações no nível do espaço de trabalho.
- A prévia das Políticas de Serviço Personalizadas Python do Unity Gateway deve estar ativada para o seu espaço de trabalho, além da prévia das Políticas de Serviço do Unity Gateway. Um administrador do espaço de trabalho ativa isso na página Pré-visualizações. Consulte Gerenciar pré-visualizações no nível do espaço de trabalho.
- O espaço de trabalho que envia as solicitações para o serviço deve estar em uma região suportada. Em outras regiões, uma política Python nega toda interação que ela avalia no modo Enforce. No modo Log , a interação prossegue e a possível negação é registrada.
- O espaço de trabalho que envia solicitações para o serviço não deve usar o perfil de segurança de conformidade, uma política de rede serverless que restrinja o acesso à internet ou bloqueia destinos específicos, nem um gateway de rede privado. Nesses espaços de trabalho, uma política do Python nega toda interação que ela avalia no modo Enforce. No modo Log , a interação prossegue e a possível negação é registrada. A verificação se aplica ao espaço de trabalho que envia a solicitação, não ao espaço de trabalho onde você anexa a política.
- Para criar a função:
USE CATALOGeUSE SCHEMAno catálogo e esquema de destino, eCREATE FUNCTIONno esquema. - Para anexar a política:
MANAGEno serviço alvo eEXECUTEna função. Os chamadores do serviço não precisam deEXECUTEna função. - Para chamar um serviço de nuvem externo a partir da função: uma credencial de serviço do Unity Catalog para esse serviço, e
ACCESSna credencial criar uma função que a declare. - Para ler um segredo da função: um segredo do Catálogo Unity.
Criar uma política Python no formulário de política
Você pode escrever, verificar e testar a função sem sair do formulário da política.
Na barra lateral do espaço de trabalho, clique em Unity Gateway.
Selecione o serviço a ser controlado: um serviço de modelo na guia Modelos , um serviço de provedor de modelos na guia Provedores ou um serviço MCP na guia MCPs .
Abra a guia Políticas e clique em Nova política.
Insira um nome para a política.
No tipo de proteção, selecione Personalizado.
Defina a Classificação para controlar a ordem de avaliação. A prioridade mais baixa vem primeiro na requisição e por último na resposta.
Em Implementação, selecione Função Personalizada.
Em Função, selecione Criar novo. No Compute para criar a função e testar, selecione um warehouse SQL. O Azure Databricks o usa apenas para criar a função e executar testes, não para avaliar o tráfego ao vivo.
Selecione Python. Para começar a partir de um modelo, selecione um, como Bloquear saída insegura ou Bloquear injeção de prompt.
Em Nome da função, insira o nome completo, por exemplo
main.governance.block_internal_hosts.Em Dependências (opcional), liste os pacotes Python que a função precisa e que ainda não estejam no ambiente, um por linha, por exemplo
phonenumbers. Azure Databricks os adiciona à cláusulaENVIRONMENTda função.(Opcional) Para usar uma credencial secreta ou de serviço, expanda Segredos e credenciais (opcional):
-
Em Segredos (opcional), liste os segredos do Catálogo Unity que a função lê, um por linha, por exemplo
main.default.api_key. - Em Credencial padrão (opcional), selecione a credencial de serviço que a função utiliza. Para adicionar mais credenciais, clique em Adicionar, depois selecione cada credencial e dê um Alias.
Azure Databricks as adiciona às cláusulas
SECRETSeCREDENTIALSda função. Veja Usar um segredo e Chamar um serviço externo com credencial de serviço.-
Em Segredos (opcional), liste os segredos do Catálogo Unity que a função lê, um por linha, por exemplo
Escreva o corpo da função no editor e clique em Verificar sintaxe.
Expandir Test function. Em
event, insira um evento de exemplo. Em um Serviço de Modelo ou Serviço de Provedor de Modelo, clique em Solicitar ou Resposta. Em um Serviço MCP, selecione uma ferramenta na ferramenta Selecionar para inserir uma chamada de ferramenta com os argumentos dessa ferramenta. Edite o evento para corresponder ao caso que deseja testar. Deixeconfigcomo{}. Clique em Executar teste. Returns mostra a decisão e o motivo, quando houver um.(Opcional) Em um serviço de modelo ou provedor de modelo, selecione Avaliação de resposta completa em Avaliação de resposta.
Clique em Criar política.
A função é criada no Catálogo Unity e a política aparece na aba Políticas do serviço. As dependências da função são instaladas na primeira vez que a política é executada, e a política nega interações até que a instalação termine. Veja Desempenho. Para reutilizar uma função que você já criou, selecione Selecionar existente em Função em vez de Criar nova.
Criar uma política Python com SQL
Você também pode criar a função com CREATE FUNCTION em um caderno de notas ou no editor SQL e então anexá-la com Select existing no formulário de política.
A função a seguir é executada em um Model Service ou Model Provider Service. Ele bloqueia respostas que contenham um nome de host interno ou um padrão de chave de acesso. Ele lê a mensagem de context.message e retorna uma decisão construída pelo ajudante policy_decision:
CREATE OR REPLACE FUNCTION main.governance.block_internal_hosts(
event VARIANT,
config VARIANT
)
RETURNS VARIANT
LANGUAGE PYTHON
ENVIRONMENT (environment_version = '6')
AS $$
import json
import re
def policy_decision(result, reason=""):
return type(event).parseJson(json.dumps({"decision": {"result": result, "reason": reason}}))
event_value = event.toPython() if hasattr(event, "toPython") else event
if event_value.get("type") != "response":
return policy_decision("ALLOW")
message = str(event_value.get("context", {}).get("message", ""))
patterns = {
"an internal hostname": r"\b[a-z0-9-]+\.corp\.example\.com\b",
"an access key": r"\bAKIA[0-9A-Z]{16}\b",
}
for label, pattern in patterns.items():
if re.search(pattern, message, flags=re.IGNORECASE):
return policy_decision("DENY", f"The response contains {label}.")
return policy_decision("ALLOW")
$$;
Para anexá-la, siga Criar uma política Python no formulário de política, mas selecione Selecionar existente em Função e escolha a função.
Escreva a função
Leia o evento
Os parâmetros event e config são valores VARIANT. Converta event para um dicionário Python com toPython(), depois leia campos com get(), para que um campo ausente não gere erro:
event_value = event.toPython() if hasattr(event, "toPython") else event
phase = event_value.get("type") # "request" or "response"
message = event_value.get("context", {}).get("message", "") # latest user or assistant message
tool = event_value.get("context", {}).get("tool", {}) # MCP Services only
Para a lista completa de campos, consulte Campos de evento.
Devolver uma decisão
Retorne a VARIANT que contém um decision objeto com a result de ALLOW, DENY, ou ASK um opcional reason.
result não diferencia maiúsculas de minúsculas. Construa o valor de retorno a partir de um dicionário com type(event).parseJson():
import json
def policy_decision(result, reason=""):
return type(event).parseJson(json.dumps({"decision": {"result": result, "reason": reason}}))
return policy_decision("DENY", "The response contains an internal hostname.")
Se a função retornar DENY sem reason, ou com um vazio, o chamador vê o motivo padrão: Access denied: this request is not permitted by a policy on this service.
Quando a política nega uma interação em um Serviço Modelo ou Serviço de Provedor de Modelo, o chamador recebe o reason no databricks_service_policy objeto. Em um Serviço MCP, o chamador recebe um erro de JSON-RPC com o reason em error.message. Veja decisões de política.
Adicionar pacotes Python
Para usar um pacote que não esteja no ambiente, liste-o em Dependências (opcional) no formulário de política ou declare-o na dependencies opção da ENVIRONMENT cláusula ao criar a função com SQL. Manter environment_version = '6':
ENVIRONMENT (
dependencies = '["phonenumbers"]',
environment_version = '6'
)
Pacotes que já estão na versão 6 do ambiente, como boto3 e requests, não precisam ser listados. Dependências são instaladas a partir do PyPI. Consulte Estender UDFs usando dependências personalizadas.
Chame um serviço externo com credenciais de serviço
Para chamar um serviço em nuvem, declare uma credencial de serviço do Catálogo Unity na cláusula CREDENTIALS e use-a por meio de databricks.service_credentials.getServiceCredentialsProvider():
CREDENTIALS (`my-credential` DEFAULT)
ENVIRONMENT (environment_version = '6')
Uma função que declara uma credencial de serviço deve definir environment_version = '6'. Se você omitir a ENVIRONMENT cláusula, a função é criada, mas a política falha com um CREDENTIALS_UNSUPPORTED_ENVIRONMENT erro ao ser executada. Para requisitos de credenciais, veja Usar uma credencial de serviço em um UDF Python.
Use um secret
Para usar um valor como uma chave de API, armazene-o como um segredo do Unity Catalog. Declare o nome em três partes do segredo na SECRETS cláusula, ou liste-o em Segredos (opcional) no formulário de política e, em seguida, leia-o no corpo da função com databricks.secrets.get(). A função deve definir environment_version = '6':
SECRETS (main.default.api_key)
ENVIRONMENT (environment_version = '6')
from databricks.secrets import get
api_key = get(catalog="main", schema="default", key="api_key")
A função pode ler apenas os segredos declarados em sua SECRETS cláusula. Não inclua um valor secreto no reason que você retorna, porque o motivo é devolvido ao chamador. Veja Usar segredos em um UDF Python.
Lidar com erros
Uma política Python falha em modo fechado, então uma exceção não tratada nega a interação com o motivo genérico Access denied: a policy on this service could not be evaluated.. Para retornar um motivo mais claro, capture exceções em torno de chamadas que podem falhar, como chamadas de rede, e retorne DENY com sua própria explicação.
Teste uma função de política em um notebook
Uma política Python falha ao fechar, então um erro de codificação em uma política ativa aparece apenas como uma interação negada com um motivo genérico. Para encontrar erros antes de anexar a política, teste o corpo da função em um notebook. O código a seguir executa o corpo da mesma forma que uma política Python faz, em função de event e config, e verifica o seguinte:
- Código: O corpo compila e suas importações carregam.
-
Contrato: O valor de retorno é um(a)
VARIANTque contém um objetodecisioncom um(a)resultdeALLOW,DENYouASK. - Veredito: A decisão sobre um pedido de exemplo e uma resposta de exemplo corresponde à que você espera.
Crie um notebook e anexe-o à computação serverless com o ambiente versão 6, o ambiente usado pelas políticas de Python.
Se a função usar pacotes que não estão no ambiente, instale-os na primeira célula com as mesmas versões das dependências da função, por
%pip install phonenumbersexemplo.Na célula seguinte, cole o corpo de função em
POLICY. Você também pode colar a declaração completaCREATE FUNCTION. Depois editeREQUEST,RESPONSE, eEXPECTEDpara os casos que você deseja testar. A célula está pré-preenchida com a função de Criar uma política Python com SQL:# Paste the function body (the code between AS $$ and $$), or the whole CREATE FUNCTION statement. POLICY = r''' import json import re def policy_decision(result, reason=""): return type(event).parseJson(json.dumps({"decision": {"result": result, "reason": reason}})) event_value = event.toPython() if hasattr(event, "toPython") else event if event_value.get("type") != "response": return policy_decision("ALLOW") message = str(event_value.get("context", {}).get("message", "")) patterns = { "an internal hostname": r"\b[a-z0-9-]+\.corp\.example\.com\b", "an access key": r"\bAKIA[0-9A-Z]{16}\b", } for label, pattern in patterns.items(): if re.search(pattern, message, flags=re.IGNORECASE): return policy_decision("DENY", f"The response contains {label}.") return policy_decision("ALLOW") ''' # Sample events. Edit them to test the cases you care about. REQUEST = {"type": "request", "context": {"message": "Where is the build server?"}} RESPONSE = {"type": "response", "context": {"message": "The build server is build-01.corp.example.com."}} # For an MCP Service, test a tool call instead, for example: # REQUEST = {"type": "request", "context": {"tool": {"name": "push_files", "arguments": {"owner": "acme", "repo": "website"}}}} CONFIG = {} # The verdict you expect for each event: "ALLOW", "DENY", or "ASK". Use None to skip the check. EXPECTED = {"request": "ALLOW", "response": "DENY"}Cole o seguinte código na última célula e execute-o:
import ast import json import linecache import re import textwrap import traceback from pyspark.sql.types import VariantVal def load_policy(source): """Compile the body as the body of policy(event, config), the way a Python policy runs it.""" match = re.search(r"\bAS\s*\$\$(.*?)\$\$", source, flags=re.DOTALL | re.IGNORECASE) body = textwrap.dedent(match.group(1) if match else source).strip("\n") + "\n" if not body.strip(): print("Code: FAIL. The function body is empty.") return None try: wrapper = ast.parse("def policy(event, config):\n pass").body[0] wrapper.body = ast.parse(body, filename="<policy>").body code = compile(ast.Module(body=[wrapper], type_ignores=[]), "<policy>", "exec") except SyntaxError as error: print(f"Code: FAIL. Syntax error on line {error.lineno} of the function body: {error.msg}") print(f" {(error.text or '').strip()}") return None # Show the body's own lines in tracebacks. linecache.cache["<policy>"] = (len(body), None, body.splitlines(True), "<policy>") namespace = {} exec(code, namespace) print("Code: PASS. The function body compiles.") return namespace["policy"] def check_contract(value): """Return (result, reason, problem). problem is None when the value follows the decision contract.""" if not isinstance(value, VariantVal): return None, None, "The function must return a VARIANT. Build it with type(event).parseJson(json.dumps(...))." data = value.toPython() decision = data.get("decision") if isinstance(data, dict) else None if not isinstance(decision, dict): return None, None, 'The return value must hold a "decision" object.' result, reason = decision.get("result"), decision.get("reason", "") if not isinstance(result, str) or result.upper() not in ("ALLOW", "DENY", "ASK"): return None, None, f'"decision.result" must be ALLOW, DENY, or ASK, not {result!r}.' if not isinstance(reason, str): return None, None, '"decision.reason" must be a string.' return result.upper(), reason, None def run_case(policy, name, event, config, expected): """Run the policy on one sample event. Return True when every check passes.""" try: value = policy(VariantVal.parseJson(json.dumps(event)), VariantVal.parseJson(json.dumps(config))) except ModuleNotFoundError as error: print(f"{name}: FAIL. Module {error.name!r} isn't installed. Install it with %pip install, " "and list it in the function's dependencies.") return False except Exception: print(f"{name}: FAIL. The function raised an error, so the policy would deny the interaction:") traceback.print_exc() return False result, reason, problem = check_contract(value) if problem: print(f"{name}: FAIL. {problem} The policy would deny the interaction.") return False print(f"{name}: {result}" + (f" ({reason})" if reason else "")) if result == "ASK" and "tool" not in event.get("context", {}): print(" Note: Model Services and Model Provider Services can't ask for approval, so here ASK blocks the interaction.") elif result == "ASK" and event.get("type") != "request": print(" Note: on an MCP tool result, ASK lets the result through. Return DENY to block it.") if expected and result != expected.upper(): print(f" FAIL. Expected {expected.upper()}.") return False return True policy = load_policy(POLICY) if policy: checks = [run_case(policy, name, event, CONFIG, EXPECTED.get(name)) for name, event in [("request", REQUEST), ("response", RESPONSE)]] print("All checks passed." if all(checks) else "Some checks failed.")
Com a função pré-preenchida e os eventos, a saída é:
Code: PASS. The function body compiles.
request: ALLOW
response: DENY (The response contains an internal hostname.)
All checks passed.
Quando uma verificação falha, a saída informa qual verificação falhou. Para um erro na função, ele também mostra o traceback do Python, com números de linha que correspondem ao corpo da função que você colou.
O notebook executa o corpo da função diretamente, não por meio de uma política, então ele não testa a cláusula da função CREDENTIALS ou as chamadas que usam credenciais de serviço. Teste esses com Test function no formulário de política.
Performance
Uma política Python adiciona latência a cada solicitação e resposta que avalia, então teste-a em tráfego realista antes de aplicá-la. Espere a seguinte latência:
-
Primeiras avaliações: Azure Databricks instala as dependências da função na primeira vez que a política é executada, não quando você a associa. Até que a instalação termine, a política nega cada interação que avalia com
Access denied: the policy function could not start in time. Try the request again.O tempo que a instalação leva depende das dependências. Com um pequeno pacote, uma tentativa de novo logo dá certo. Um pacote grande pode demorar muito mais. Se você alterar as dependências da função, elas serão instaladas novamente. - Avaliações posteriores: Após a instalação das dependências, uma avaliação normalmente leva de 1 a 2 segundos, dependendo da função e de suas dependências.
- Chamadas externas: Uma chamada a um serviço externo adiciona a latência desse serviço.
Para verificar se a política está pronta, envie uma solicitação que ela deve negar, por exemplo, do AI Playground, e tente novamente até que a política retorne seu próprio veredito. Para uma política no modo Log , verifique o possível veredito na tabela unificada de rastreamento.
Para reduzir o impacto, mantenha as funções pequenas, limite dependências e anexe uma política Python apenas aos serviços que precisam dela. O Databricks recomenda iniciar no modo Log para medir a latência e revisar decisões antes de migrar para o Enforce.
Limitations
As seguintes limitações se aplicam:
- Regiões: Disponível apenas nas regiões listadas em Disponibilidade, com base na região do espaço de trabalho que envia a solicitação.
- Espaços de trabalho: Não disponíveis em espaços de trabalho que utilizam o perfil de segurança de conformidade, uma política de rede serverless que restringe o acesso à internet ou bloqueia destinos específicos, ou um gateway de rede privado. Consulte Antes de começar.
- Tipo de função: Somente UDFs escalares do Catálogo Unity em Python são suportados. UDFs Python em lote do Unity Catalog não são suportados.
-
Versão de ambiente: Somente
environment_version = '6'é suportada. - Tempo de expiração: Cada avaliação expira após 30 segundos, incluindo o tempo para iniciar o ambiente da função. Você não pode alterar esse tempo limite.
- Memória: Uma função de política pode usar até 500 MiB de memória. Se usar mais, a política nega a interação.
- Dependências: Dependências do PyPI são suportadas. Dependências de arquivos em volumes do Catálogo Unity não são suportadas.
- Conexões do Catálogo Unity: As funções não podem usar conexões do Catálogo Unity. Use uma credencial de serviço para chamar serviços em nuvem.
- Tipos de conteúdo: A função recebe apenas conteúdo de texto. Imagens, áudio e outros conteúdos multimodais não são avaliados.
-
Decisões: Uma política Python retorna
ALLOW,DENY, ouASK. Não pode censurar ou reescrever conteúdo. - Avaliação de resposta: Em serviços de modelo e provedor de modelos, as políticas Python suportam avaliação em streaming, avaliação padrão ou avaliação de resposta completa. Com a avaliação por streaming, a função é invocada para verificações na janela de resposta e pode receber apenas parte da resposta. Selecione Avaliação de resposta completa se a função precisar da resposta completa antes que qualquer texto seja liberado. Consulte Streaming responses.
Troubleshooting
| Sintoma | Causa provável |
|---|---|
A política falha com CREDENTIALS_UNSUPPORTED_ENVIRONMENT. |
A função declara uma credencial de serviço, mas não define environment_version = '6'. Recrie a função com ENVIRONMENT (environment_version = '6'). |
Interações são negadas com Access denied: a policy on this service could not be evaluated. |
A função gerou uma exceção não tratada, importou um pacote que não está instalado ou retornou NULL, então a política falha em modo fechado. Execute a função em Função de teste com um evento de exemplo, ou teste-a em um notebook para ver o erro. Capture exceções em torno de chamadas externas e liste cada pacote que não esteja no ambiente nas dependências da função. |
Interações são negadas com Access denied: the policy function did not return a value that could be interpreted as a decision. |
O valor de retorno não segue o formato de decisão: ele não é um VARIANT que contém um objeto decision, ou seu result não é ALLOW, DENY ou ASK. Construa o valor de retorno com type(event).parseJson().
Veja Retornar uma decisão. |
Os chamadores veem o reason da função nas solicitações que ela deve permitir. |
A função retorna um result não é uma decisão válida, mas reason é uma cadeia de caracteres, a política nega a interação e retorna esse motivo. Verifique a ortografia de result. |
| As chamadas para um serviço externo falham. | A credencial de serviço não é declarada na CREDENTIALS cláusula, a função não usa getServiceCredentialsProvider(), ou o papel da credencial não permite a ação. Verifique a credencial e suas permissões. |
No modo Enforce , toda interação é negada com Python service policies are not available yet in this region. |
O espaço de trabalho que enviou a solicitação não está em uma região suportada. Chame o serviço a partir de um espaço de trabalho em uma região suportada ou desvincule a política Python do serviço. No modo Log , a interação prossegue e a possível negação é registrada. |
No modo Enforce , toda interação é negada com Python service policies are not yet available in workspaces .... |
O espaço de trabalho que enviou a solicitação usa o perfil de segurança de conformidade, uma política de rede serverless que restringe o acesso à internet ou bloqueia destinos específicos, ou um gateway de rede privado. O motivo indica qual é. Após alterar a configuração do espaço de trabalho, a alteração pode levar até 2 minutos para entrar em vigor. Consulte Antes de começar. |
Interações são negadas com Access denied: the policy function could not start in time. Try the request again. |
O ambiente da função não estava pronto a tempo. Isso é esperado na primeira vez que a política é executada e depois que você altera suas dependências, durante a instalação delas. Tente novamente a solicitação. Veja Desempenho. |
Interações são negadas com Access denied: the policy function did not complete within the 30s timeout. |
A função, incluindo o tempo para iniciar seu ambiente, demorou mais de 30 segundos. Defina tempos de espera para chamadas externas e mantenha a função rápida. |
Interações são negadas com Access denied: the policy function ran out of memory. |
A função utilizava mais de 500 MiB de memória. Reduza o uso de memória da função, por exemplo, carregando menos dados ou usando dependências menores. |