Exibição no momento:
Versão do portal Foundry (clássico) - Alternar para a versão do novo portal Foundry
Os Modelos da Fábrica da Microsoft permitem que você acesse os modelos mais poderosos de provedores de modelos líderes por meio de um único ponto de extremidade e um conjunto de credenciais. Essa funcionalidade permite alternar entre modelos e usá-los em seu aplicativo sem alterar nenhum código.
Este artigo explica como os serviços Foundry organizam modelos e como usar o endpoint de inferência para acessá-los.
Importante
Azure SDK beta de inferência de IA foi preterido e será desativado em 26 de agosto de 2026. Mudar para a API OpenAI/v1 geralmente disponível com um SDK estável da OpenAI. Siga o guia de migração para alternar para OpenAI/v1 usando o SDK para sua linguagem de programação preferida.
Implantações
O Foundry usa implantações para disponibilizar modelos.
As implantações dão um nome a um modelo e definem configurações específicas. Você pode acessar um modelo usando seu nome de implantação em suas solicitações.
Uma implantação inclui:
- Um nome do modelo
- Uma versão do modelo
- Um tipo de provisionamento ou capacidade1
- Uma configuração de filtragem de conteúdo1
- Uma configuração de limitação de taxa1
1 Essas configurações podem ser alteradas dependendo do modelo selecionado.
Um recurso Foundry pode ter muitas implantações de modelo. Você paga apenas pela inferência executada em implantações de modelo. As implantações são recursos do Azure, portanto, estão sujeitas às políticas do Azure.
Para obter mais informações sobre como criar implantações, consulte Adicionar e configurar implantações de modelo.
Pontos de extremidade
Os serviços do Foundry fornecem vários pontos de extremidade dependendo do tipo de trabalho que você deseja realizar:
Ponto de extremidade de inferência de IA do Azure
O endpoint de inferência do Azure AI, geralmente no formato https://<resource-name>.services.ai.azure.com/models, permite que você use um único endpoint com a mesma autenticação e esquema para gerar inferência para os modelos implantados no recurso. Todos os Modelos de Fundição suportam essa capacidade. Esse ponto de extremidade segue a Azure API de Inferência de Modelo de IA, que dá suporte às seguintes modalidades:
- Inserções de texto
- Incorporações de imagem
- Finalizações de chat
Roteamento
O ponto de extremidade de inferência roteia solicitações para uma implantação específica, correspondendo ao parâmetro name na solicitação com o nome da implantação. Essa configuração significa que as implantações funcionam como um alias para um modelo em determinadas configurações. Essa flexibilidade permite implantar um modelo várias vezes no serviço, mas com configurações diferentes, se necessário.
Por exemplo, se você criar uma implantação nomeada Mistral-large, poderá invocar essa implantação da seguinte maneira:
Instale o pacote azure-ai-inference usando o gerenciador de pacotes, como pip:
pip install azure-ai-inference
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
import os
from azure.ai.inference import ChatCompletionsClient
from azure.core.credentials import AzureKeyCredential
client = ChatCompletionsClient(
endpoint="https://<resource>.services.ai.azure.com/models",
credential=AzureKeyCredential(os.environ["AZURE_INFERENCE_CREDENTIAL"]),
)
Explore nossas samples e leia a documentação de referência API para começar.
Instale o pacote @azure-rest/ai-inference usando o npm:
npm install @azure-rest/ai-inference
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
import ModelClient from "@azure-rest/ai-inference";
import { isUnexpected } from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";
const client = new ModelClient(
"https://<resource>.services.ai.azure.com/models",
new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL)
);
Explore nossas samples e leia a documentação de referência API para começar.
Instale a biblioteca de inferência de IA Azure com o seguinte comando:
dotnet add package Azure.AI.Inference --prerelease
Importe os seguintes namespaces:
using Azure;
using Azure.Identity;
using Azure.AI.Inference;
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
ChatCompletionsClient client = new ChatCompletionsClient(
new Uri("https://<resource>.services.ai.azure.com/models"),
new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);
Explore nossos exemplos e leia a documentação de referência da API para começar.
Adicione o pacote ao seu projeto:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-inference</artifactId>
<version>1.0.0-beta.1</version>
</dependency>
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
ChatCompletionsClient client = new ChatCompletionsClientBuilder()
.credential(new AzureKeyCredential("{key}"))
.endpoint("https://<resource>.services.ai.azure.com/models")
.buildClient();
Explore nossas samples e leia a documentação de referência API para começar.
Use a seção de referência para explorar o design da API e quais parâmetros estão disponíveis. Por exemplo, a seção de referência para Conclusões de Chat detalha como usar a rota /chat/completions para gerar previsões com base em instruções formatadas para chat. Observe que o caminho /models está incluído na raiz da URL:
Solicitação
POST https://<resource>.services.ai.azure.com/models/chat/completions?api-version=2024-05-01-preview
api-key: <api-key>
Content-Type: application/json
Para um modelo de chat, você pode criar uma solicitação da seguinte maneira:
from azure.ai.inference.models import SystemMessage, UserMessage
response = client.complete(
messages=[
SystemMessage(content="You are a helpful assistant."),
UserMessage(content="Explain Riemann's conjecture in 1 paragraph"),
],
model="mistral-large"
)
print(response.choices[0].message.content)
var messages = [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Explain Riemann's conjecture in 1 paragraph" },
];
var response = await client.path("/chat/completions").post({
body: {
messages: messages,
model: "mistral-large"
}
});
console.log(response.body.choices[0].message.content)
requestOptions = new ChatCompletionsOptions()
{
Messages = {
new ChatRequestSystemMessage("You are a helpful assistant."),
new ChatRequestUserMessage("Explain Riemann's conjecture in 1 paragraph")
},
Model = "mistral-large"
};
response = client.Complete(requestOptions);
Console.WriteLine($"Response: {response.Value.Content}");
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant"));
chatMessages.add(new ChatRequestUserMessage("Explain Riemann's conjecture in 1 paragraph"));
ChatCompletions chatCompletions = client.complete(new ChatCompletionsOptions(chatMessages));
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.println("Response:" + message.getContent());
}
Solicitação
POST https://<resource>.services.ai.azure.com/models/chat/completions?api-version=2024-05-01-preview
api-key: <api-key>
Content-Type: application/json
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
"role": "user",
"content": "Explain Riemann's conjecture in 1 paragraph"
}
],
"model": "mistral-large"
}
Se você especificar um nome de modelo que não corresponda a nenhuma implantação de modelo, receberá um erro de que o modelo não existe. Você controla quais modelos estão disponíveis para os usuários criando implantações de modelo. Para obter mais informações, consulte adicionar e configurar implantações de modelo.
Ponto de extremidade de inferência do OpenAI do Azure
A API Azure OpenAI expõe todos os recursos de modelos OpenAI e dá suporte a mais recursos como assistentes, threads, arquivos e inferência em lote. Você também pode acessar modelos não OpenAI por essa rota.
Os pontos de extremidade OpenAI do Azure, geralmente do formulário https://<resource-name>.openai.azure.com, funcionam no nível de implantação e cada implantação tem sua própria URL associada. No entanto, você pode usar o mesmo mecanismo de autenticação para acessar as implementações. Para obter mais informações, consulte a página de referência para Azure API OpenAI.
Cada implantação tem uma URL formada pela concatenação da URL base Azure OpenAI e a rota /deployments/<model-deployment-name>.
Instale o pacote openai usando o gerenciador de pacotes, como pip:
pip install openai --upgrade
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
import os
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint = "https://<resource>.services.ai.azure.com"
api_key=os.getenv("AZURE_INFERENCE_CREDENTIAL"),
api_version="2024-10-21",
)
Instale o pacote openai usando o npm:
npm install openai
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
import { AzureKeyCredential } from "@azure/openai";
const endpoint = "https://<resource>.services.ai.azure.com";
const apiKey = new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL);
const apiVersion = "2024-10-21"
const client = new AzureOpenAI({
endpoint,
apiKey,
apiVersion,
"deepseek-v3-0324"
});
Aqui, deepseek-v3-0324 é o nome de uma implantação de modelo no recurso Microsoft Foundry.
Instale a biblioteca OpenAI com o seguinte comando:
dotnet add package Azure.AI.OpenAI --prerelease
Você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
AzureOpenAIClient client = new(
new Uri("https://<resource>.services.ai.azure.com"),
new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);
Adicione o pacote ao seu projeto:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-openai</artifactId>
<version>1.0.0-beta.16</version>
</dependency>
Então, você pode usar o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir conclusões de chat:
OpenAIClient client = new OpenAIClientBuilder()
.credential(new AzureKeyCredential("{key}"))
.endpoint("https://<resource>.services.ai.azure.com")
.buildClient();
Use a seção de referência para explorar o design da API e quais parâmetros estão disponíveis. Por exemplo, a seção de referência para conclusões de chat detalha como usar a rota /chat/completions para gerar previsões com base em instruções formatadas em chat:
Solicitação
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
Aqui, deepseek-v3-0324 é o nome de uma implantação de modelo no recurso Foundry.
response = client.chat.completions.create(
model="deepseek-v3-0324", # Replace with your model deployment name.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain Riemann's conjecture in 1 paragraph"}
]
)
print(response.model_dump_json(indent=2)
var messages = [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Explain Riemann's conjecture in 1 paragraph" },
];
const response = await client.chat.completions.create({ messages, model: "deepseek-v3-0324" });
console.log(response.choices[0].message.content)
ChatCompletion response = chatClient.CompleteChat(
[
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("Explain Riemann's conjecture in 1 paragraph"),
]);
Console.WriteLine($"{response.Role}: {response.Content[0].Text}");
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant"));
chatMessages.add(new ChatRequestUserMessage("Explain Riemann's conjecture in 1 paragraph"));
ChatCompletions chatCompletions = client.getChatCompletions("deepseek-v3-0324",
new ChatCompletionsOptions(chatMessages));
System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
System.out.println("Message:");
System.out.println(message.getContent());
}
Aqui, deepseek-v3-0324 é o nome de uma implantação de modelo no recurso Microsoft Foundry.
Solicitação
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
"role": "user",
"content": "Explain Riemann's conjecture in 1 paragraph"
}
]
}
Aqui, deepseek-v3-0324 é o nome de uma implantação de modelo no recurso Foundry.
Para obter mais informações sobre como usar o ponto de extremidade do OpenAI do Azure, consulte a documentação OpenAI do Azure em Modelos do Foundry.
Autenticação sem chave
Os modelos implantados nos Modelos da Fábrica no Foundry Tools dão suporte à autorização sem chave usando o Microsoft Entra ID. A autorização sem chave aprimora a segurança, simplifica a experiência do usuário, reduz a complexidade operacional e fornece suporte robusto de conformidade para o desenvolvimento moderno. Isso torna a autorização sem chave uma opção forte para as organizações que adotam soluções de gerenciamento de identidade seguras e escalonáveis.
Para usar a autenticação sem chave, configure seu recurso e conceda acesso aos usuários para executar a inferência. Depois de configurar o recurso e conceder acesso, autentique da seguinte maneira:
Instale o SDK do OpenAI usando um gerenciador de pacotes como pip:
pip install openai
Para Microsoft Entra ID autenticação, instale também:
pip install azure-identity
Use o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir preenchimentos de chat com o Microsoft Entra ID e fazer uma chamada de teste para o ponto de extremidade de preenchimentos de chat com a implantação do seu modelo.
Substitua <resource> pelo nome do recurso Foundry. Localize-o no portal do Azure ou executando az cognitiveservices account list. Substitua DeepSeek-V3.1 pelo nome da implantação real.
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(),
"https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://<resource>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
completion = client.chat.completions.create(
model="DeepSeek-V3.1", # Required: your deployment name
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is Azure AI?"}
]
)
print(completion.choices[0].message.content)
Saída esperada
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Referência: OpenAI Python SDK e classeDefaultAzureCredential.
Instale o SDK do OpenAI:
dotnet add package OpenAI
Para Microsoft Entra ID autenticação, instale também o pacote Azure.Identity:
dotnet add package Azure.Identity
Importe os seguintes namespaces:
using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;
Em seguida, use o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir preenchimentos de chat com o Microsoft Entra ID e, depois, fazer uma chamada de teste para o ponto de extremidade de preenchimentos de chat com a implantação do seu modelo.
Substitua <resource> pelo nome do recurso Foundry (localize-o no portal Azure). Substitua gpt-4o-mini pelo nome da implantação real.
#pragma warning disable OPENAI001
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
ChatClient client = new(
model: "gpt-4o-mini", // Your deployment name
authenticationPolicy: tokenPolicy,
options: new OpenAIClientOptions() {
Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1/")
}
);
ChatCompletion completion = client.CompleteChat(
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("What is Azure AI?")
);
Console.WriteLine(completion.Content[0].Text);
Saída esperada:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Referência: OpenAI .NET SDK e classe DefaultAzureCredential.
Instale o SDK do OpenAI com npm:
npm install openai
Para Microsoft Entra ID autenticação, instale também:
npm install @azure/identity
Em seguida, use o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir preenchimentos de chat com o Microsoft Entra ID e, depois, fazer uma chamada de teste para o ponto de extremidade de preenchimentos de chat com a implantação do seu modelo.
Substitua <resource> pelo nome do recurso Foundry (localize-o no portal do Azure ou executando az cognitiveservices account list). Substitua DeepSeek-V3.1 pelo nome da implantação real.
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { OpenAI } from "openai";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
'https://ai.azure.com/.default'
);
const client = new OpenAI({
baseURL: "https://<resource>.openai.azure.com/openai/v1/",
apiKey: tokenProvider
});
const completion = await client.chat.completions.create({
model: "DeepSeek-V3.1", // Required: your deployment name
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "What is Azure AI?" }
]
});
console.log(completion.choices[0].message.content);
Saída esperada:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Referência: OpenAI Node.js classe SDK e DefaultAzureCredential.
Adicione o SDK do OpenAI ao seu projeto. Verifique o OpenAI Java GitHub repositório para obter as instruções de versão e instalação mais recentes.
Para a autenticação do Microsoft Entra ID, além disso, adicione:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.0</version>
</dependency>
Em seguida, use o pacote para consumir o modelo. O exemplo a seguir mostra como criar um cliente para consumir preenchimentos de chat com o Microsoft Entra ID e, depois, fazer uma chamada de teste para o ponto de extremidade de preenchimentos de chat com a implantação do seu modelo.
Substitua <resource> pelo nome do recurso Foundry (localize-o no portal Azure). Substitua DeepSeek-V3.1 pelo nome da implantação real.
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.chat.completions.*;
DefaultAzureCredential tokenCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://<resource>.openai.azure.com/openai/v1/")
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
tokenCredential,
"https://ai.azure.com/.default"
)
))
.build();
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.addSystemMessage("You are a helpful assistant.")
.addUserMessage("What is Azure AI?")
.model("DeepSeek-V3.1") // Required: your deployment name
.build();
ChatCompletion completion = client.chat().completions().create(params);
System.out.println(completion.choices().get(0).message().content());
Saída esperada:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Referência: OpenAI Java SDK e classeDefaultAzureCredential.
Explore o design da API na seção de referência para ver quais parâmetros estão disponíveis. Indique o token de autenticação no cabeçalho Authorization. Por exemplo, a seção de referência Preenchimento de chat detalha como usar a rota /chat/completions para gerar previsões com base em instruções formatadas pelo chat. O caminho /models está incluído na raiz da URL:
Solicitação
Substitua <resource> pelo nome do recurso Foundry (localize-o no portal do Azure ou executando az cognitiveservices account list). Substitua MAI-DS-R1 pelo nome da implantação real.
A base_url aceitará ambos os formatos https://<resource>.openai.azure.com/openai/v1/ e https://<resource>.services.ai.azure.com/openai/v1/.
curl -X POST https://<resource>.openai.azure.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
-d '{
"model": "MAI-DS-R1",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Explain what the bitter lesson is?"
}
]
}'
Resposta
Se a autenticação for bem-sucedida, você receberá uma 200 OK resposta com os resultados de conclusão do chat no corpo da resposta:
{
"id": "chatcmpl-...",
"object": "chat.completion",
"created": 1738368234,
"model": "MAI-DS-R1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The bitter lesson refers to a key insight in AI research that emphasizes the importance of general-purpose learning methods that leverage computation, rather than human-designed domain-specific approaches. It suggests that methods which scale with increased computation tend to be more effective in the long run."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 28,
"completion_tokens": 52,
"total_tokens": 80
}
}
Os tokens devem ser emitidos com escopo https://ai.azure.com/.default.
Para fins de teste, a maneira mais fácil de obter um token válido para sua conta de usuário é usar o CLI do Azure. Em um console, execute o seguinte comando CLI do Azure:
az account get-access-token --resource https://cognitiveservices.azure.com --query "accessToken" --output tsv
Esse comando gera um token de acesso que você pode armazenar na variável de $AZURE_OPENAI_AUTH_TOKEN ambiente.
Referência: API de Conclusões de Chat
Limitações
- Você não pode usar o Azure OpenAI Batch com o endpoint dos Foundry Models. Você precisa usar a URL de implantação dedicada, conforme explicado no suporte à API Batch na documentação do Azure OpenAI.
- Não há suporte para a API em tempo real no endpoint de inferência. Use uma URL de implantação dedicada.
Conteúdo relacionado