Início Rápido: gerar imagens com o Serviço OpenAI do Azure

Use este guia para começar a gerar imagens com o Azure OpenAI no seu navegador com o IA do Azure Foundry.

Pré-requisitos

Uma assinatura do Azure. Crie um gratuitamente.
Um recurso do OpenAI do Azure criado em uma região com suporte. Confira a Disponibilidade de região. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Vá para o Azure AI Foundry

Navegue até o Azure AI Foundry e entre com as credenciais associadas ao seu recurso do OpenAI do Azure. Durante o fluxo de trabalho de entrada, selecione o diretório apropriado, a assinatura do Azure e o recurso OpenAI do Azure.

Na página inicial do IA do Azure Foundry, crie ou selecione um novo projeto. Navegue até a página Modelos + pontos de extremidade no painel de navegação esquerdo. Selecione Implantar modelo e escolha um dos modelos DALL-E na lista. Conclua o processo de implantação.

Na página do modelo, selecione Abrir no playground.

Experimente a geração de imagens

Comece a explorar os recursos do Azure OpenAI com uma abordagem sem código por meio do playground de imagens. Insira o prompt da imagem na caixa de texto e selecione Gerar. Quando a imagem gerada por IA estiver pronta, ela aparecerá na página.

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o OpenAI do Azure reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo Filtragem de conteúdo.

No Playground de imagens, você também pode visualizar exemplos de código Python e cURL, que são pré-preenchidos de acordo com suas configurações. Selecione Exibir código na parte superior da página. Você pode utilizar esse código para escrever um aplicativo que conclua a mesma tarefa.

Limpar os recursos

Caso queria limpar e remover um recurso do OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Experimente alguns exemplos no repositório GitHub de Exemplos do OpenAI do Azure.
Confira a Referência de API

Utilize este guia para começar a chamar as APIs REST de geração de imagem do Serviço OpenAI do Azure usando o Python.

Uma assinatura do Azure. Crie um gratuitamente.
Python 3.8 ou versão posterior.
As seguintes bibliotecas Python instaladas: os, requests, json.
Um recurso do OpenAI do Azure criado em uma região com suporte. Confira a Disponibilidade de região.
Em seguida, você precisa implantar um modelo de dalle3 com o recurso do Azure. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para chamar com êxito as APIs do OpenAI do Azure, você precisa das seguintes informações sobre seu recurso do OpenAI do Azure:

Variável	Nome	Valor
Ponto de extremidade	`api_base`	O valor do ponto de extremidade está localizado em Chaves e Ponto de Extremidade para o seu recurso no portal do Azure. Você também pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
Chave	`api_key`	O valor da chave está localizado em Chaves e Ponto de Extremidade para o seu recurso no portal do Azure. O Azure gera duas chaves para o seu recurso. Você pode usar qualquer dos dois valores.

Acesse o seu recurso no portal do Azure. No painel de navegação, selecione Chaves e Ponto de Extremidade em Gerenciamento de Recursos. Copie o valor do Ponto de Extremidade e um valor de chave de acesso. Você pode usar o valor da CHAVE 1 ou o valor da CHAVE 2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um novo aplicativo Python

Crie um novo arquivo Python denominado quickstart.py. Abra o novo arquivo em seu IDE ou editor preferido.

Substitua o conteúdo do quickstart.py pelo código a seguir. Altere o valor de prompt para seu texto preferido.

DALL-E 3
DALL-E 2 (versão prévia)

Você também precisa substituir <dalle3> na URL pelo nome de implantação escolhido ao implantar o modelo DALL-E 3. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente. Se você encontrar um erro, verifique novamente se não há uma duplicação do / na separação entre seu ponto de extremidade e /openai/deployments.

import requests
import time
import os
api_base = os.environ['AZURE_OPENAI_ENDPOINT']  # Enter your endpoint here
api_key = os.environ['AZURE_OPENAI_API_KEY']         # Enter your API key here

api_version = '2024-02-01'
url = f"{api_base}/openai/deployments/<dalle3>/images/generations?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
    # Enter your prompt text here
    "prompt": "A multi-colored umbrella on the beach, disposable camera",
    "size": "1024x1024", # supported values are “1792x1024”, “1024x1024” and “1024x1792” 
    "n": 1, #The number of images to generate. Only n=1 is supported for DALL-E 3.
    "quality": "hd", # Options are “hd” and “standard”; defaults to standard 
    "style": "vivid" # Options are “natural” and “vivid”; defaults to “vivid”
}
submission = requests.post(url, headers=headers, json=body)

image_url = submission.json()['data'][0]['url']

print(image_url)

O script faz uma chamada à API de geração de imagem síncrona.

import requests
import time
import os

api_base = os.environ['AZURE_OPENAI_ENDPOINT'] # Enter your endpoint here
api_key = os.environ['AZURE_OPENAI_API_KEY']         # Enter your API key here

# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only)
api_version = '2023-06-01-preview'

# Define the prompt for the image generation
url = f"{api_base}openai/images/generations:submit?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
    # Enter your prompt text here
    "prompt": "a multi-colored umbrella on the beach, disposable camera",  
    "size": "1024x1024",
    "n": 1
}
submission = requests.post(url, headers=headers, json=body)

# Call the API to generate the image and retrieve the response
operation_location = submission.headers['operation-location']
status = ""
while (status != "succeeded"):
    time.sleep(1)
    response = requests.get(operation_location, headers=headers)
    status = response.json()['status']
image_url = response.json()['result']['data'][0]['url']

print(image_url)

O script fará uma chamada à API de geração de imagem e depois fará um loop até que a imagem gerada esteja pronta.

Importante

Lembre-se de remover a chave do código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais. Para saber mais, veja Azure Key Vault

Execute o aplicativo com o comando python:
```
python quickstart.py
```
Leva alguns minutos para obter a resposta.

Saída

A saída de uma chamada à API de geração de imagem bem-sucedida tem a seguinte aparência. O campo url contém uma URL na qual é possível baixar a imagem gerada. A URL permanece ativa por 24 horas.

DALL-E 3
DALL-E 2 (versão prévia)

{ 
    "created": 1698116662, 
    "data": [ 
        { 
            "url": "<URL_to_generated_image>",
            "revised_prompt": "<prompt_that_was_used>" 
        }
    ]
}

{
    "created": 1685130482,
    "expires": 1685216887,
    "id": "088e4742-89e8-4c38-9833-c294a47059a3",
    "result":
    {
        "data":
        [
            {
                "url": "<URL_to_generated_image>"
            }
        ]
    },
    "status": "succeeded"
}

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não gera uma imagem. Para obter mais informações, consulte o artigo Filtragem de conteúdo. Para obter os exemplos de respostas de erro, consulte o guia de instruções DALL-E.

O sistema retornará um status de operação de Failed e o valor error.code na mensagem será definido como contentFilter. Veja um exemplo:

DALL-E 3
DALL-E 2 (versão prévia)

{
    "created": 1698435368,
    "error":
    {
        "code": "contentFilter",
        "message": "Your task failed as a result of our safety system."
    }
}

{
   "created": 1589478378,
   "error": {
       "code": "contentFilter",
       "message": "Your task failed as a result of our safety system."
   },
   "id": "9484f239-9a05-41ba-997b-78252fec4b34",
   "status": "failed"
}

Também é possível que a própria imagem gerada seja filtrada. Nesse caso, a mensagem de erro é definida como Generated image was filtered as a result of our safety system.. Veja um exemplo:

DALL-E 3
DALL-E 2 (versão prévia)

{
    "created": 1698435368,
    "error":
    {
        "code": "contentFilter",
        "message": "Generated image was filtered as a result of our safety system."
    }
}

{
   "created": 1589478378,
   "expires": 1589478399,
   "id": "9484f239-9a05-41ba-997b-78252fec4b34",
   "lastActionDateTime": 1589478378,
   "data": [
       {
           "url": "<URL_TO_IMAGE>"
       },
       {
           "error": {
               "code": "contentFilter",
               "message": "Generated image was filtered as a result of our safety system."
           }
       }
   ],
   "status": "succeeded"
}

Limpar os recursos

Caso queria limpar e remover um recurso do OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Experimente alguns exemplos no repositório GitHub de Exemplos do OpenAI do Azure.
Confira a Referência de API

Use este guia para começar a gerar imagens com o SDK para Python do OpenAI do Azure no seu navegador.

Código-fonte da biblioteca | Pacote | Amostras

Pré-requisitos

DALL-E 3
DALL-E 2 (versão prévia)

Uma assinatura do Azure. Crie um gratuitamente.
Python 3.8 ou versão posterior.
Um recurso do OpenAI do Azure criado em uma região compatível. Confira a Disponibilidade de região.
Em seguida, você precisa implantar um modelo de dalle3 com o recurso do Azure. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para chamar com êxito as APIs do OpenAI do Azure, você precisa das seguintes informações sobre seu recurso do OpenAI do Azure:

Variável	Nome	Valor
Ponto de extremidade	`api_base`	O valor do ponto de extremidade está localizado em Chaves e Ponto de Extremidade para o seu recurso no portal do Azure. Você também pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
Chave	`api_key`	O valor da chave está localizado em Chaves e Ponto de Extremidade para o seu recurso no portal do Azure. O Azure gera duas chaves para o seu recurso. Você pode usar qualquer dos dois valores.

Acesse o seu recurso no portal do Azure. No painel de navegação, selecione Chaves e Ponto de Extremidade em Gerenciamento de Recursos. Copie o valor do Ponto de Extremidade e um valor de chave de acesso. Você pode usar o valor da CHAVE 1 ou o valor da CHAVE 2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Instalar o SDK do Python

Abra um prompt de comando e navegue até a pasta do projeto. Instale o SDK do Python do OpenAI usando o seguinte comando:

DALL-E 3
DALL-E 2 (versão prévia)

pip install openai

Importante

Atualmente, a última versão da biblioteca do OpenAI Python não dá suporte ao DALL-E 2 quando usada com o OpenAI do Azure. Para acessar o DALL-E 2 com o OpenAI do Azure, use a versão 0.28.1. Ou, então, siga o guia de migração para usar o DALL-E 2 com o OpenAI 1.x.

pip install openai==0.28.1

Instale também as seguintes bibliotecas:

pip install requests
pip install pillow

Gerar imagens com DALL-E

Crie um novo arquivo Python, quickstart.py. Abra-o no seu editor ou IDE preferido.

Substitua o conteúdo do quickstart.py pelo código a seguir.

DALL-E 3
DALL-E 2 (versão prévia)

from openai import AzureOpenAI
import os
import requests
from PIL import Image
import json

client = AzureOpenAI(
    api_version="2024-02-01",  
    api_key=os.environ["AZURE_OPENAI_API_KEY"],  
    azure_endpoint=os.environ['AZURE_OPENAI_ENDPOINT']
)

result = client.images.generate(
    model="dalle3", # the name of your DALL-E 3 deployment
    prompt="a close-up of a bear walking throughthe forest",
    n=1
)

json_response = json.loads(result.model_dump_json())

# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')

# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)

# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated_image.png')

# Retrieve the generated image
image_url = json_response["data"][0]["url"]  # extract image URL from response
generated_image = requests.get(image_url).content  # download the image
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

# Display the image in the default image viewer
image = Image.open(image_path)
image.show()

Insira a URL do ponto de extremidade e a chave nos campos apropriados.
Altere o valor de prompt para seu texto preferido.
Altere o valor de model para o nome do modelo DALL-E 3 implantado.

import openai
import os
import requests
from PIL import Image

# Get endpoint and key from environment variables
openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT']
openai.api_key = os.environ['AZURE_OPENAI_API_KEY']     

# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only)
openai.api_version = '2023-06-01-preview'
openai.api_type = 'azure'

# Create an image by using the image generation API
generation_response = openai.Image.create(
    prompt='A painting of a dog',    # Enter your prompt text here
    size='1024x1024',
    n=2
)

# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')

# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)

# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated_image.png')

# Retrieve the generated image
image_url = generation_response["data"][0]["url"]  # extract image URL from response
generated_image = requests.get(image_url).content  # download the image
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

# Display the image in the default image viewer
image = Image.open(image_path)
image.show()

Insira a URL do ponto de extremidade e a chave nos campos apropriados.
Altere o valor de prompt para seu texto preferido.

Importante

Lembre-se de remover a chave do código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais. Para saber mais, veja Azure Key Vault

Execute o aplicativo com o comando python:

python quickstart.py

Leva alguns minutos para obter a resposta.

Saída

O OpenAI do Azure armazena a imagem de saída no arquivo generated_image.png no diretório especificado. O script também exibirá a imagem em seu visualizador de imagens padrão.

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não gera uma imagem. Para obter mais informações, consulte o artigo Filtragem de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso do OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Experimente alguns exemplos no repositório GitHub de Exemplos do OpenAI do Azure.
Confira a Referência de API

Use este guia para começar a gerar imagens com o SDK para C# do OpenAI do Azure no seu navegador.

Código-fonte da biblioteca | Pacote (NuGet) | Amostras

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
O SDK do .NET 7
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um aplicativo .NET Core

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando dotnet new para criar um novo aplicativo do console com o nome azure-openai-quickstart. Este comando cria um projeto "Olá, Mundo" simples com um único arquivo de origem C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Altere o diretório para a pasta do aplicativo recém-criado. É possível criar o aplicativo com:

dotnet build

A saída de compilação não deve conter nenhum aviso ou erro.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Instalar o SDK do .NET do OpenAI

Instalar a biblioteca de clientes com:

dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.6

Gerar imagens com DALL-E

No diretório do projeto, abra o arquivo program.cs e substitua o conteúdo pelo seguinte código:

using Azure;
using Azure.AI.OpenAI;
using OpenAI.Images;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ImageClient chatClient = azureClient.GetImageClient("dalle-3");

var imageGeneration = await chatClient.GenerateImageAsync(
        "a happy monkey sitting in a tree, in watercolor",
        new ImageGenerationOptions()
        {
            Size = GeneratedImageSize.W1024xH1024
        }
    );

Console.WriteLine(imageGeneration.Value.ImageUri);

Crie e execute o aplicativo a partir do seu diretório de aplicativos com estes comandos:

dotnet build
dotnet run

Saída

A URL da imagem gerada é impressa no console.

https://dalleproduse.blob.core.windows.net/private/images/b7ac5e55-f1f8-497a-8d0e-8f51446bf538/generated_00.png?se=2024-07-12T13%3A47%3A56Z&sig=Zri37iYVTVtc52qzTFBOqPgSHvXwEhcO86Smv2ojB%2FE%3D&ske=2024-07-17T12%3A15%3A44Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2024-07-10T12%3A15%3A44Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo filtro de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Para mais exemplos, confira o repositório do GitHub de amostras do OpenAI do Azure.

Use este guia para começar a gerar imagens com o SDK para Java do OpenAI do Azure no seu navegador.

Código-fonte da biblioteca | Artefato (Maven) | Amostras

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
A versão atual do JDK (Java Development Kit)
A ferramenta de build Gradle ou outro gerenciador de dependência.
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um aplicativo Java

Criar um novo projeto Gradle.

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Instalar o SDK do Java

Este início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca de clientes e informações para outros gerenciadores de dependência no Repositório Central do Maven.

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Esta configuração define o projeto como um aplicativo Java cujo ponto de entrada é a classe OpenAIQuickstart. Isso importa a biblioteca da Visão de IA do Azure.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.3")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Gerar imagens com DALL-E

Criar um arquivo Java.

Em seu diretório de trabalho, execute o comando a seguir para criar uma pasta de origem do projeto:
```
mkdir -p src/main/java
```
Navegue até a nova pasta e crie um arquivo chamado OpenAIQuickstart.java.

Abra OpenAIQuickstart.java em seu editor ou IDE de preferência e cole o código a seguir.

import com.azure.ai.openai.OpenAIAsyncClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.azure.ai.openai.models.ImageGenerationOptions;
import com.azure.ai.openai.models.ImageLocation;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.models.ResponseError;

import java.util.concurrent.TimeUnit;

/**
 * Sample demonstrates how to get the images for a given prompt.
 */
public class OpenAIQuickstart {

    /**
     * Runs the sample algorithm and demonstrates how to get the images for a given prompt.
     *
     * @param args Unused. Arguments to the program.
     */
    public static void main(String[] args) throws InterruptedException {

        // Get key and endpoint from environment variables:
        String azureOpenaiKey = System.getenv("AZURE_OPENAI_API_KEY");
        String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");

        OpenAIAsyncClient client = new OpenAIClientBuilder()
            .endpoint(endpoint)
            .credential(new AzureKeyCredential(azureOpenaiKey))
            .buildAsyncClient();

        ImageGenerationOptions imageGenerationOptions = new ImageGenerationOptions(
            "A drawing of the Seattle skyline in the style of Van Gogh");
        client.getImages(imageGenerationOptions).subscribe(
            images -> {
                for (ImageLocation imageLocation : images.getData()) {
                    ResponseError error = imageLocation.getError();
                    if (error != null) {
                        System.out.printf("Image generation operation failed. Error code: %s, error message: %s.%n",
                            error.getCode(), error.getMessage());
                    } else {
                        System.out.printf(
                            "Image location URL that provides temporary access to download the generated image is %s.%n",
                            imageLocation.getUrl());
                    }
                }
            },
            error -> System.err.println("There was an error getting images." + error),
            () -> System.out.println("Completed getImages."));

        // The .subscribe() creation and assignment is not a blocking call. For the purpose of this example, we sleep
        // the thread so the program does not end before the send operation is complete. Using .block() instead of
        // .subscribe() will turn this into a synchronous call.
        TimeUnit.SECONDS.sleep(10);
    }
}

Navegue de volta para a pasta raiz do projeto e compile o aplicativo com:
```
gradle build
```
Em seguida, execute-o com o comando gradle run:
```
gradle run
```

Saída

A URL da imagem gerada é impressa no console.

Image location URL that provides temporary access to download the generated image is https://dalleproduse.blob.core.windows.net/private/images/d2ea917f-8802-4ad6-8ef6-3fb7a15c8482/generated_00.png?se=2023-08-25T23%3A11%3A28Z&sig=%2BKa5Mkb9U88DfvxoBpyAjamYRzwb7aVCEucM6XJC3wQ%3D&ske=2023-08-31T15%3A27%3A47Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-24T15%3A27%3A47Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02.
Completed getImages.

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo filtro de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Use este guia para começar a gerar imagens com o SDK para JavaScript do OpenAI do Azure no seu navegador.

Documentação de referência | Código-fonte | Pacote (npm) | Exemplos

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Versões LTS do Node.js
A CLI do Azure usada para autenticação sem senha em um ambiente de desenvolvimento local, crie o contexto necessário entrando com a CLI do Azure.
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um aplicativo Node

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele. Em seguida, execute o comando npm init para criar um aplicativo de nó com um arquivo package.json.

npm init

Instalar a biblioteca de clientes

Instale as bibliotecas de cliente com:

npm install openai @azure/identity

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Gerar imagens com DALL-E

Crie um novo arquivo chamado ImageGeneration.js e abra-o em seu editor de código preferido. Copie o código a seguir no arquivo ImageGeneration.js:

Microsoft Entra ID
Chave de API

const { AzureOpenAI } = require("openai");
const { 
    DefaultAzureCredential, 
    getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Execute o script com o seguinte comando:

node ImageGeneration.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
const apiKey = process.env["AZURE_OPENAI_API_KEY"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

function getClient() {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Execute o script com o seguinte comando:

node ImageGeneration.js

Saída

A URL da imagem gerada é impressa no console.

== Batch Image Generation ==
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_00.png?se=2023-08-29T19%3A12%3A57Z&sig=655GkWajOZ9ALjFykZF%2FBMZRPQALRhf4UPDImWCQoGI%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_01.png?se=2023-08-29T19%3A12%3A57Z&sig=B24ymPLSZ3HfG23uojOD9VlRFGxjvgcNmvFo4yPUbEc%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo filtro de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Para mais exemplos, confira o repositório do GitHub de amostras do OpenAI do Azure.

Use este guia para começar a gerar imagens com o SDK para JavaScript do OpenAI do Azure no seu navegador.

Documentação de referência | Código-fonte | Pacote (npm) | Exemplos

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Versões LTS do Node.js
TypeScript
A CLI do Azure usada para autenticação sem senha em um ambiente de desenvolvimento local, crie o contexto necessário entrando com a CLI do Azure.
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um aplicativo Node

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele. Em seguida, execute o comando npm init para criar um aplicativo de nó com um arquivo package.json.

npm init

Instalar a biblioteca de clientes

Instale as bibliotecas de cliente com:

npm install openai @azure/identity

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Gerar imagens com DALL-E

Crie um arquivo chamado ImageGeneration.ts e abra-o no seu editor de código preferido. Copie o código a seguir no arquivo ImageGeneration.ts:

Microsoft Entra ID
Chave de API

import { AzureOpenAI } from "openai";
import { 
    DefaultAzureCredential, 
    getBearerTokenProvider 
} from "@azure/identity";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Compile o aplicativo com o seguinte comando:
```
tsc
```
Execute o aplicativo com o seguinte comando:
```
node ImageGeneration.js
```

import { AzureOpenAI } from "openai";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
const apiKey = process.env["AZURE_OPENAI_API_KEY"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Compile o aplicativo com o seguinte comando:
```
tsc
```
Execute o aplicativo com o seguinte comando:
```
node ImageGeneration.js
```

Saída

A URL da imagem gerada é impressa no console.

== Batch Image Generation ==
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_00.png?se=2023-08-29T19%3A12%3A57Z&sig=655GkWajOZ9ALjFykZF%2FBMZRPQALRhf4UPDImWCQoGI%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_01.png?se=2023-08-29T19%3A12%3A57Z&sig=B24ymPLSZ3HfG23uojOD9VlRFGxjvgcNmvFo4yPUbEc%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo filtro de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Para mais exemplos, confira o repositório do GitHub de amostras do OpenAI do Azure.

Use este guia para começar a gerar imagens com o SDK para Go do OpenAI do Azure no seu navegador.

Código-fonte da biblioteca | Pacote | Amostras

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Go 1.8 ou posterior
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Criar um aplicativo Go

Abra o prompt de comando e navegue até a pasta do seu projeto. Crie um novo sample.go de arquivo.

Instalar o SDK do Go

Instale o SDK do Go do OpenAI usando o seguinte comando:

go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai@latest

Ou, se você usar dep, execute o seguinte no repositório:

dep ensure -add github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai

Gerar imagens com DALL-E

Abra sample.go no editor de código preferido.

Adicione o seguinte código ao script:

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// handle error
	}

	resp, err := client.GetImageGenerations(context.TODO(), azopenai.ImageGenerationOptions{
		Prompt:         to.Ptr("a painting of a cat in the style of Dali"),
		ResponseFormat: to.Ptr(azopenai.ImageGenerationResponseFormatURL),
	}, nil)

	if err != nil {
		// handle error
	}

	for _, generatedImage := range resp.Data {
		// the underlying type for the generatedImage is dictated by the value of
		// ImageGenerationOptions.ResponseFormat. In this example we used `azopenai.ImageGenerationResponseFormatURL`,
		// so the underlying type will be ImageLocation.

		resp, err := http.Head(*generatedImage.URL)

		if err != nil {
			// handle error
		}

		fmt.Fprintf(os.Stderr, "Image generated, HEAD request on URL returned %d\nImage URL: %s\n", resp.StatusCode, *generatedImage.URL)
	}
}

Execute o script usando o comando go run:

go run sample.go

Saída

A URL da imagem gerada é impressa no console.

Image generated, HEAD request on URL returned 200
Image URL: https://dalleproduse.blob.core.windows.net/private/images/d7b28a5c-ca32-4792-8c2a-6a5d8d8e5e45/generated_00.png?se=2023-08-29T17%3A05%3A37Z&sig=loqntaPypYVr9VTT5vpbsjsCz31g1GsdoQi0smbGkks%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Observação

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não retornará uma imagem gerada. Para obter mais informações, consulte o artigo filtro de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso do OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.
Para mais exemplos, confira o repositório do GitHub de amostras do OpenAI do Azure.

Utilize este guia para começar a chamar as APIs REST de geração de imagem do Serviço OpenAI do Azure por meio do PowerShell.

Observação

A API de geração de imagens cria uma imagem a partir de uma solicitação de texto. Ele não edita imagens existentes nem cria variações.

Pré-requisitos

Uma assinatura do Azure. Crie um gratuitamente.
Para essa tarefa, recomenda-se a versão mais recente do PowerShell 7 pois os exemplos usam novos recursos não disponíveis no Windows PowerShell 5.1.
Um recurso do OpenAI do Azure criado em uma região com suporte (consulte disponibilidade da região). Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Instalação

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade por meio da página Implantações no portal do Azure AI Foundry. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Gerar imagens com o DALL-E 2

Criar um novo arquivo do PowerShell nomeado quickstart.ps1. Abra o novo arquivo em seu IDE ou editor preferido.

Substitua o conteúdo de quickstart.ps1 pelo código a seguir. Insira a URL do ponto de extremidade e a chave nos campos apropriados. Altere o valor de prompt para seu texto preferido.

# Azure OpenAI metadata variables
$openai = @{
  api_key     = $Env:AZURE_OPENAI_API_KEY
  api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
  api_version = '2023-06-01-preview' # this may change in the future
}

# Text to describe image
$prompt = 'A painting of a dog'

# Header for authentication
$headers = [ordered]@{
  'api-key' = $openai.api_key
}

# Adjust these values to fine-tune completions
$body = [ordered]@{
   prompt = $prompt
   size   = '1024x1024'
   n      = 1
} | ConvertTo-Json

 # Call the API to generate the image and retrieve the response
$url = "$($openai.api_base)/openai/images/generations:submit?api-version=$($openai.api_version)"

$submission = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json' -ResponseHeadersVariable submissionHeaders

 $operation_location = $submissionHeaders['operation-location'][0]
 $status = ''
 while ($status -ne 'succeeded') {
     Start-Sleep -Seconds 1
     $response = Invoke-RestMethod -Uri $operation_location -Headers $headers
     $status   = $response.status
 }

# Set the directory for the stored image
$image_dir = Join-Path -Path $pwd -ChildPath 'images'

# If the directory doesn't exist, create it
if (-not(Resolve-Path $image_dir -ErrorAction Ignore)) {
    New-Item -Path $image_dir -ItemType Directory
}

# Initialize the image path (note the filetype should be png)
$image_path = Join-Path -Path $image_dir -ChildPath 'generated_image.png'

# Retrieve the generated image
$image_url = $response.result.data[0].url  # extract image URL from response
$generated_image = Invoke-WebRequest -Uri $image_url -OutFile $image_path  # download the image
return $image_path

Importante

Para produção, use um modo seguro de armazenar e acessar suas credenciais, como o Gerenciamento de Segredo do PowerShell com o Azure Key Vault. Para obter mais informações sobre segurança de credenciais, consulte o artigo segurança dos serviços de IA do Azure.

Execute o script usando o PowerShell:
```
./quickstart.ps1
```
O script será executado em um loop até que a imagem gerada esteja pronta.

Saída

O PowerShell solicita a imagem do Azure OpenAI e armazena a imagem de saída no arquivo generated_image.png no diretório especificado. Por conveniência, o caminho completo do arquivo é retornado no final do script.

As APIs de geração de imagem vêm com um filtro de moderação de conteúdo. Se o serviço reconhecer seu prompt como conteúdo prejudicial, ele não gera uma imagem. Para obter mais informações, consulte o artigo Filtragem de conteúdo.

Limpar os recursos

Caso queria limpar e remover um recurso do OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Explore as APIs de geração de imagem com mais profundidade no guia de instruções DALL-E.

Experimente alguns exemplos no repositório GitHub de Exemplos do OpenAI do Azure.

Compartilhar via

Pré-requisitos

Vá para o Azure AI Foundry

Experimente a geração de imagens

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um novo aplicativo Python

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Instalar o SDK do Python

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo .NET Core

Instalar o SDK do .NET do OpenAI

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Java

Instalar o SDK do Java

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Node

Instalar a biblioteca de clientes

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Node

Instalar a biblioteca de clientes

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Go

Instalar o SDK do Go

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Instalação

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Gerar imagens com o DALL-E 2

Saída