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

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

Pré-requisitos

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

Uma assinatura do Azure. Crie uma gratuitamente.
Acesso concedido ao DALL-E na assinatura do Azure desejada.
Um recurso do Azure OpenAI criado na região EastUS, AustraliaEast ou SwedenCentral.
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.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Vá para o Estúdio OpenAI do Azure

Navegue até o Estúdio do OpenAI do Azure em 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.

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

Na página inicial do Estúdio do OpenAI do Azure, selecione playground DALL·E (versão prévia) para usar as APIs de geração de imagem. Selecione Configurações próximo à parte superior da página e confirme se a lista suspensa Implantação tem sua implantação DALL-E 3 selecionada.

Experimente a geração de imagens

Comece a explorar os recursos do OpenAi do Azure com uma abordagem sem código por meio do playground DALL·E (versão prévia). 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 DALL·E (Versão prévia), você também pode visualizar amostras de código Python e cURL, que são pré-preenchidas 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 uma gratuitamente.
Acesso concedido ao DALL-E na assinatura do Azure desejada.
Python 3.8 ou versão posterior.
As seguintes bibliotecas Python instaladas: os, requests, json.
Um recurso do Azure OpenAI criado na região EastUS, AustraliaEast ou SwedenCentral.
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.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

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. Como alternativa, você pode encontrar o valor em Estúdio do OpenAI do Azure>Playground>Exibição de Código. 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.

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. Insira a URL do ponto de extremidade e a chave nos campos apropriados. 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 = '<your_endpoint>'  # Enter your endpoint here
api_key = '<your_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 = '<your_endpoint>'  # Enter your endpoint here
api_key = '<your_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 uma gratuitamente.
Acesso concedido ao DALL-E na assinatura do Azure desejada.
Python 3.8 ou versão posterior.
Um recurso do Azure OpenAI criado na região EastUS, AustraliaEast ou SwedenCentral.
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.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Configuraçã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. Como alternativa, você pode encontrar o valor em Estúdio do OpenAI do Azure>Playground>Exibição de Código. 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.

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

Variáveis de ambiente

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

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

Abra um prompt de comando e navegue até a pasta do projeto. Crie um novo arquivo Python, quickstart.py.

Instalar o SDK do Python

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

Abra _quickstart.py em 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
Acesso ao Serviço OpenAI do Azure concedido para a assinatura do Azure desejada. No momento, o acesso a esse serviço é permitido somente por aplicativo. Você pode solicitar acesso ao Serviço OpenAI do Azure preenchendo o formulário em https://aka.ms/oai/access.
O SDK do .NET 7
Um recurso do OpenAI do Azure criado na região leste dos EUA. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Configuraçã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`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Como alternativa, você pode encontrar o valor em Estúdio OpenAI do Azure>Playground>Exibição de código. 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.

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 pelo seguinte código:

using System;
using System.IO;
using System.Threading.Tasks;
using Azure.AI.OpenAI;

namespace Azure.AI.OpenAI.Tests.Samples
{
    public partial class GenerateImages
    {
        // add an async Main method:
        public static async Task Main(string[] args)
        {
            string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
            string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

            OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key));

            Response<ImageGenerations> imageGenerations = await client.GetImageGenerationsAsync(
                new ImageGenerationOptions()
                {
                    Prompt = "a happy monkey eating a banana, in watercolor",
                    Size = ImageSize.Size256x256,
                });

            // Image Generations responses provide URLs you can use to retrieve requested images
            Uri imageUri = imageGenerations.Value.Data[0].Url;
            
            // Print the image URI to console:
            Console.WriteLine(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/552c5522-af4a-4877-a19c-400fac04a422/generated_00.png?se=2023-08-17T16%3A54%3A40Z&sig=XGCIx9r0WvWTJ0LL%2FJGymo2WYp4FDbSQNNrGRUnnUzI%3D&ske=2023-08-19T01%3A10%3A14Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-12T01%3A10%3A14Z&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
Acesso permitido ao Serviço OpenAI do Azure na assinatura do Azure desejada. No momento, o acesso a esse serviço é permitido somente por aplicativo. Você pode solicitar acesso ao Serviço OpenAI do Azure preenchendo o formulário em https://aka.ms/oai/access.

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 na região leste dos EUA. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Configuraçã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`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Como alternativa, você pode encontrar o valor em Estúdio OpenAI do Azure>Playground>Exibição de código. 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.

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.

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

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Acesso permitido ao Serviço OpenAI do Azure na assinatura do Azure desejada. No momento, o acesso a esse serviço é permitido somente por aplicativo. Você pode solicitar acesso ao Serviço OpenAI do Azure preenchendo o formulário em https://aka.ms/oai/access.
Versões LTS do Node.js
Um recurso do OpenAI do Azure criado na região leste dos EUA. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Configuraçã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`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Como alternativa, você pode encontrar o valor em Estúdio OpenAI do Azure>Playground>Exibição de código. 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.

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 a biblioteca de clientes do OpenAI do Azure para JavaScript com npm:

npm install @azure/openai

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:

const { OpenAIClient, AzureKeyCredential } = require("@azure/openai");

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

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const size = "256x256";

// The number of images to generate
const n = 2;

async function main() {
    console.log("== Batch Image Generation ==");
  
    const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));
    const deploymentName = "dall-e";
    const results = await client.getImages(deploymentName, prompt, { n, size });
  
    for (const image of results.data) {
      console.log(`Image generation result URL: ${image.url}`);
    }
    //console.log(`Image generation result URL: ${results.result.status}`);
}

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 Go do OpenAI do Azure no seu navegador.

Código-fonte da biblioteca | Pacote | Amostras

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Acesso concedido ao DALL-E na assinatura do Azure desejada Atualmente, o acesso a esse serviço é concedido apenas por aplicativo. Você pode solicitar acesso ao Serviço OpenAI do Azure preenchendo o formulário em https://aka.ms/oai/access. Os clientes existentes do OpenAI do Azure precisam inserir novamente o formulário para ter acesso ao DALL-E. Abra um problema neste repositório para entrar em contato conosco se você tiver algum problema.

Go 1.8 ou posterior

Um recurso do OpenAI do Azure criado na região leste dos EUA. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

Configuraçã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`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Como alternativa, você pode encontrar o valor em Estúdio OpenAI do Azure>Playground>Exibição de código. 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.

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/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, err := azopenai.NewKeyCredential(azureOpenAIKey)

	if err != nil {
		// handle error
	}

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

	if err != nil {
		// handle error
	}

	resp, err := client.CreateImage(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 usando 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 uma gratuitamente.
Acesso concedido ao DALL-E na assinatura do Azure desejada.
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 na região leste dos EUA. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Observação

Atualmente, você deve enviar um aplicativo para acessar o Serviço OpenAI do Azure. Para solicitar acesso, preencha este formulário. Se precisar de assistência, abra uma notificação de problema neste repositório para entrar em contato com a Microsoft.

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. Como alternativa, você pode encontrar o valor em Estúdio do OpenAI do Azure>Playground>Exibição de Código. 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.

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

Variáveis de ambiente

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'

$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Encontrei um problema com a configuração.

Criar um novo script do PowerShell

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.

Pré-requisitos

Vá para o Estúdio OpenAI do Azure

Experimente a geração de imagens

Limpar os recursos

Próximas etapas

Pré-requisitos

Recuperar chave e ponto de extremidade

Criar um novo aplicativo Python

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um novo aplicativo Python

Instalar o SDK do Python

Gerar imagens com DALL-E

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuraçã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

Configuraçã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

Configuraçã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

Configuraçã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

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um novo script do PowerShell

Saída

Limpar os recursos

Próximas etapas

Recursos adicionais