Azure modely generování imagí OpenAI

Důležité

Model generování image dall-e-3 DALL-E byl vyřazen 4. března 2026 a už není k dispozici pro nová nasazení. Existující nasazení nejsou funkční. gpt-image- Místo toho použijte model řady pro generování imagí. Aktualizované pokyny najdete v průvodci generováním imagí .

Modely generování imagí OpenAI vytvářejí obrázky z uživatelem zadaných textových výzev a volitelných obrázků. Tento článek vysvětluje, jak tyto modely používat, konfigurovat možnosti a využívat výhod pokročilých možností generování imagí v Azure.

Generování imagí můžete provádět prostřednictvím rozhraní API pro generování obrázků nebo rozhraní API pro odpovědi. Nebo můžete experimentovat s generováním obrázků na portálu Foundry.

Pokud chcete vybrat upřednostňovaný přístup a model rozhraní API, použijte karty na začátku této stránky.

Modely a možnosti

V této tabulce se seznámíte s rozdíly mezi různými modely generování obrázků a pomůžete vám zvolit nejlepší model pro potřeby generování imagí.

Aspekt GPT-Image-2 GPT-Image-1.5 GPT-Image-1 GPT-Image-1-Mini
Dostupnost Public Preview Omezený přístup ve verzi Preview (platí pro přístup k GPT-image-1.5) Omezený přístup ve verzi Preview (platí pro přístup GPT-image-1) Omezený přístup ve verzi Preview (platí pro přístup GPT-image-1)
Silné Nejlepší pro vysokovýsměrné a 4K generace, vylepšené úpravy obrázků a podporu širokého poměru stran Nejlepší pro realismus, instruktážní, multimodální kontext a vyšší rychlost a náklady Nejlepší pro realismus, sledování instrukcí a multimodální kontext Nejvhodnější pro rychlé vytváření prototypů, hromadné generování nebo případy použití citlivé na náklady
Vstupní a výstupní režimy a formát Přijímá text + vstupy obrázků; výstupy obrázků pouze v base64 (bez možnosti adresy URL). Přijímá text + vstupy obrázků; výstupy obrázků pouze v base64 (bez možnosti adresy URL). Přijímá text + vstupy obrázků; výstupy obrázků pouze v base64 (bez možnosti adresy URL). Přijímá text + vstupy obrázků; výstupy obrázků pouze v base64 (bez možnosti adresy URL).
Velikosti a rozlišení obrázků Libovolná rozlišení: obě hrany musí být násobky 16 pixelů; dlouhá hrana až 3 840 px (4K); poměr stran až do 3:1; počet pixelů 655 360–8 294 400 1024×1024, 1024×1536, 1536×1024 1024×1024, 1024×1536, 1536×1024 1024×1024, 1024×1536, 1536×1024
Možnosti kvality Přepracované kontroly kvality: low, medium, highje low optimalizované pro případy použití citlivé na latenci low, medium, high (výchozí = vysoká) low, medium, high (výchozí = vysoká) low, medium, high (výchozí = střední)
Početobrázkůch 1–10 obrázků na požadavek (n parametr) 1–10 obrázků na požadavek (n parametr) 1–10 obrázků na požadavek (n parametr) 1–10 obrázků na požadavek (n parametr)
Úpravy (inpainting / varianty) ✅ Vylepšení výkonu úprav pomocí neprůspěšných a variací ✅ Podporuje neprůspěšné a variace s maskou a výzvou. ✅ Podporuje neprůspěšné a variace s maskou a výzvou. ✅ Podporuje neprůspěšné a variace s maskou a výzvou.
Zachování tváře ✅ Pokročilá zachování tváře pro realistické a konzistentní výsledky ✅ Pokročilá zachování tváře pro realistické a konzistentní výsledky ✅ Pokročilá zachování tváře pro realistické a konzistentní výsledky ❌ Žádná vyhrazená ochrana obličeje; lepší pro neportrétní/obecné kreativní obrázky
Výkon a náklady Vysoce věrný model optimalizovaný pro realismus ; vyšší latence a náklady Vysoce věrný model optimalizovaný pro realismus ; vyšší efektivita a latence oproti GPT-Image-1 Vysoce věrný model optimalizovaný pro realismus ; vyšší latence a náklady Nákladově efektivní a rychlejší pro rozsáhlé nebo iterativní generování

Rychlý start

V této příručce můžete začít volat rozhraní REST API Azure OpenAI v rozhraních REST API Microsoft Generování obrázků Foundry Models pomocí Python.

Požadavky

Instalace

Načtení klíče a koncového bodu

K úspěšnému volání rozhraní API Azure OpenAI potřebujete následující informace o prostředku Azure OpenAI:

Proměnné Jméno Hodnotu
Koncový bod api_base Hodnota koncového bodu se nachází v části Klíče a koncového bodu pro váš prostředek na portálu Azure. Koncový bod najdete také na stránce Nasazení na portálu Foundry. Ukázkový koncový bod je: https://docs-test-001.openai.azure.com/.
Klíč api_key Hodnota klíče se nachází také v části Keys a Endpoint pro váš prostředek na portálu Azure. Azure pro váš prostředek vygeneruje dva klíče. Můžete použít kteroukoli hodnotu.

Na portálu Azure přejděte ke svému prostředku. V navigačním podokně vyberte v části Správa prostředkůklíče a koncový bod. Zkopírujte hodnotu koncového bodu a hodnotu přístupového klíče. Můžete použít hodnotu KLÍČ 1 nebo KLÍČ 2 . Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Screenshot, která zobrazuje stránku Klíče a koncový bod prostředku Azure OpenAI na portálu Azure portal.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Doporučujeme Microsoft Entra ID ověřování pomocí spravovaných identit pro prostředky Azure, abyste se vyhnuli ukládání přihlašovacích údajů s aplikacemi, které běží v cloudu.

Používejte klíče rozhraní API s opatrností. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně. Pokud používáte klíče rozhraní API, bezpečně je uložte do Azure Key Vault, pravidelně obměňujte klíče a omezte přístup k Azure Key Vault pomocí řízení přístupu na základě rolí a omezení přístupu k síti. Další informace o bezpečném používání klíčů API v aplikacích najdete v tématu KLÍČEAPI s Azure Key Vault.

Další informace o zabezpečení služeb AI najdete v tématu Authenticate požadavků na Služby Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření nové aplikace Python

Vytvořte nový soubor Python s názvem quickstart.py. V preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) otevřete nový soubor.

  1. Obsah quickstart.py nahraďte následujícím kódem. Změňte hodnotu prompt na upřednostňovaný text. Nastavte deployment také název nasazení, který jste zvolili při nasazení modelu generování image.

    import os
import requests
import base64
from PIL import Image
from io import BytesIO

# set environment variables
endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
subscription_key = os.getenv("AZURE_OPENAI_API_KEY")

deployment = "gpt-image-1.5" # the name of your GPT-image series deployment
api_version = "2025-04-01-preview" # or later version

def decode_and_save_image(b64_data, output_filename):
  image = Image.open(BytesIO(base64.b64decode(b64_data)))
  image.show()
  image.save(output_filename)

def save_all_images_from_response(response_data, filename_prefix):
  for idx, item in enumerate(response_data['data']):
    b64_img = item['b64_json']
    filename = f"{filename_prefix}_{idx+1}.png"
    decode_and_save_image(b64_img, filename)
    print(f"Image saved to: '{filename}'")

base_path = f'openai/deployments/{deployment}/images'
params = f'?api-version={api_version}'

generation_url = f"{endpoint}{base_path}/generations{params}"
generation_body = {
  "prompt": "girl falling asleep",
  "n": 1,
  "size": "1024x1024",
  "quality": "medium",
  "output_format": "png",
  # "background": "transparent",  # "auto" or "transparent" (GPT-image-1 only; requires PNG output)
  # "output_compression": 100,  # 0-100 compression level (JPEG output only)
}
generation_response = requests.post(
  generation_url,
  headers={
    'Api-Key': subscription_key,
    'Content-Type': 'application/json',
  },
  json=generation_body
).json()
save_all_images_from_response(generation_response, "generated_image")

# In addition to generating images, you can edit them.
edit_url = f"{endpoint}{base_path}/edits{params}"
edit_body = {
  "prompt": "girl falling asleep",
  "n": 1,
  "size": "1024x1024",
  "quality": "medium"
}
files = {
  "image": ("generated_image_1.png", open("generated_image_1.png", "rb"), "image/png"),
  # You can use a mask to specify which parts of the image you want to edit.
  # The mask must be the same size as the input image.
  # "mask": ("mask.png", open("mask.png", "rb"), "image/png"),
}
edit_response = requests.post(
  edit_url,
  headers={'Api-Key': subscription_key},
  data=edit_body,
  files=files
).json()
save_all_images_from_response(edit_response, "edited_image")

    Skript vytvoří synchronní volání rozhraní API pro generování obrázků.

    Důležité

    Nezapomeňte klíč odebrat z kódu, až budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání a přístupu k vašim přihlašovacím údajům. Další informace najdete v tématu Azure Key Vault.

  2. Spusťte aplikaci pomocí python příkazu:

    python quickstart.py

    Počkejte chvíli, než se odpověď zobrazí.

Výstup

Výstup z úspěšného volání rozhraní API pro generování imagí vypadá jako v následujícím příkladu. Pole b64_json obsahuje výstupní data obrázku s kódováním base64.

{ 
    "created": 1698116662, 
    "data": [ 
        { 
            "b64_json": "<base64 image data>"
        }
    ]
}

Úspěšná odpověď zahrnuje:

  • Časové created razítko (unixový epochový čas)
  • Pole data s alespoň jedním objektem obrázku – buď hodnota (data obrázků s kódováním b64_json base64) pro každý vygenerovaný obrázek

Běžné chyby

Chyba Způsobit Rozlišení
DeploymentNotFound Název nasazení neexistuje nebo je chybně napsaný. Ověření názvu nasazení na portálu Azure nebo na portálu Foundry
401 Unauthorized Neplatný nebo chybějící klíč rozhraní API Zkontrolujte, jestli AZURE_OPENAI_API_KEY je proměnná prostředí správně nastavená.
429 Too Many Requests Překročení limitu rychlosti Implementace logiky opakování s exponenciálním zpochybněním
content_policy_violation Výzva nebo vygenerovaný výstup blokovaný filtrem obsahu Úprava výzvy tak, aby vyhovovala zásadám obsahu
InvalidPayload Chybějící požadované parametry nebo neplatné hodnoty Zkontrolujte, zda promptjsou správně zadány , sizea n jsou správně zadány.

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu. Příklady chybových odpovědí najdete v průvodci generováním obrázků.

Systém vrátí stav Failed operace a error.code hodnota ve zprávě je nastavena na contentFilter. Tady je příklad:

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

Je také možné, že se vygenerovaná image filtruje. V tomto případě je chybová zpráva nastavena na Generated image was filtered as a result of our safety system.. Tady je příklad:

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

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

V této příručce můžete začít generovat image pomocí sady Azure OpenAI SDK pro Python.

Zdrojový kód | knihovnyBalíček | Vzorky

Požadavky

Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Instalace

Načtení klíče a koncového bodu

K úspěšnému volání rozhraní API Azure OpenAI potřebujete následující informace o prostředku Azure OpenAI:

Proměnné Jméno Hodnotu
Koncový bod api_base Hodnota koncového bodu se nachází v části Klíče a koncového bodu pro váš prostředek na portálu Azure. Koncový bod najdete také prostřednictvím stránky Deployments na portálu Microsoft Foundry. Ukázkový koncový bod je: https://docs-test-001.openai.azure.com/.
Klíč api_key Hodnota klíče se nachází také v části Keys a Endpoint pro váš prostředek na portálu Azure. Azure pro váš prostředek vygeneruje dva klíče. Můžete použít kteroukoli hodnotu.

Na portálu Azure přejděte ke svému prostředku. V navigačním podokně vyberte v části Správa prostředkůklíče a koncový bod. Zkopírujte hodnotu koncového bodu a hodnotu přístupového klíče. Můžete použít hodnotu KLÍČ 1 nebo KLÍČ 2 . Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Screenshot, která zobrazuje stránku Klíče a koncový bod prostředku Azure OpenAI na portálu Azure portal.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Doporučujeme Microsoft Entra ID ověřování pomocí spravovaných identit pro prostředky Azure, abyste se vyhnuli ukládání přihlašovacích údajů s aplikacemi, které běží v cloudu.

Používejte klíče rozhraní API s opatrností. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně. Pokud používáte klíče rozhraní API, bezpečně je uložte do Azure Key Vault, pravidelně obměňujte klíče a omezte přístup k Azure Key Vault pomocí řízení přístupu na základě rolí a omezení přístupu k síti. Další informace o bezpečném používání klíčů API v aplikacích najdete v tématu KLÍČEAPI s Azure Key Vault.

Další informace o zabezpečení služeb AI najdete v tématu Authenticate požadavků na Služby Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

Instalace sady Python SDK

Otevřete příkazový řádek a přejděte do složky projektu. Pomocí následujícího příkazu nainstalujte sadu OpenAI Python SDK:

pip install openai

Nainstalujte také následující knihovny:

pip install requests
pip install pillow

Generování imagí

Vytvořte nový soubor Pythonu quickstart.py. Otevřete ho v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

Obsah quickstart.py nahraďte následujícím kódem.

from openai import AzureOpenAI
import os
import base64
from PIL import Image

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

result = client.images.generate(
    model="gpt-image-1", # the name of your GPT-image series deployment
    prompt="a close-up of a bear walking through the forest",
    n=1,
    size="1024x1024",
    quality="high",
    output_format="png",
    # background="transparent",  # Set to "transparent" for transparent backgrounds (GPT-image-1 only; requires PNG)
    # output_compression=100,  # 0-100 compression level (JPEG output only)
)

# 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')

# GPT-image-1 models always return base64-encoded image data
image_base64 = result.data[0].b64_json
generated_image = base64.b64decode(image_base64)
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()
  1. Ujistěte se, AZURE_OPENAI_ENDPOINT že jsou nastavené proměnné prostředí.AZURE_OPENAI_API_KEY
  2. Změňte hodnotu prompt na upřednostňovaný text.
  3. Změňte hodnotu model na název nasazeného modelu řady GPT-image.

Důležité

Nezapomeňte klíč odebrat z kódu, až budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání a přístupu k vašim přihlašovacím údajům. Další informace najdete v tématu Azure Key Vault.

Spusťte aplikaci pomocí python příkazu:

python quickstart.py

Počkejte chvíli, než se odpověď zobrazí.

Výstup

Azure OpenAI uloží výstupní obrázek do souboru generated_image.png v zadaném adresáři. Skript také zobrazí obrázek ve výchozím prohlížeči obrázků.

Úspěšná odpověď zahrnuje:

  • Časové created razítko
  • Pole data s alespoň jedním objektem obrázku
  • b64_json Pole s daty obrázků s kódováním Base64 (modely GPT-image-1 vždy vracejí base64)

Běžné chyby

Chyba Způsobit Rozlišení
DeploymentNotFound Název nasazení neexistuje nebo je chybně napsaný. Ověření názvu nasazení na portálu Azure nebo na portálu Foundry
AuthenticationError Neplatný nebo chybějící klíč rozhraní API Zkontrolujte, jestli AZURE_OPENAI_API_KEY je proměnná prostředí správně nastavená.
RateLimitError Překročení limitu rychlosti Implementace logiky opakování s exponenciálním zpochybněním
content_policy_violation Výzva nebo vygenerovaný výstup blokovaný filtrem obsahu Úprava výzvy tak, aby vyhovovala zásadám obsahu

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

V této příručce můžete začít generovat image pomocí sady Azure OpenAI SDK pro jazyk C#.

zdrojový kód Klibrary | Package (NuGet) | Samples

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Nastavit

  1. Vytvořte novou složku image-quickstart a přejděte do složky rychlý start pomocí následujícího příkazu:

    mkdir image-quickstart && cd image-quickstart

  2. Vytvořte novou konzolovou aplikaci pomocí následujícího příkazu:

    dotnet new console

  3. Nainstalujte klientskou knihovnu OpenA .NET I pomocí příkazu dotnet add package:

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

  4. Pro potvěné ověřování bez klíčů pomocí Microsoft Entra ID nainstalujte Azure. Balíček Identity s:

    dotnet add package Azure.Identity

  5. Pro potvěné ověřování bez klíčů pomocí Microsoft Entra ID se přihlaste k Azure pomocí následujícího příkazu:

    az login

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Spuštění rychlého startu

Ukázkový kód v tomto rychlém startu používá Microsoft Entra ID pro doporučené ověřování bez klíčů. Pokud dáváte přednost použití klíče rozhraní API, můžete objekt nahradit DefaultAzureCredential objektem AzureKeyCredential .

AzureOpenAIClient openAIClient = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential());

Pokud chcete spustit rychlý start, postupujte takto:

  1. Nahraďte obsah Program.cs následujícím kódem a aktualizujte zástupné hodnoty vlastními.

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

string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? "https://<your-resource-name>.openai.azure.com/";
string key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? "<your-key>";

// Use the recommended keyless credential instead of the AzureKeyCredential credential.
AzureOpenAIClient openAIClient = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential()); 
//AzureOpenAIClient openAIClient = new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ImageClient chatClient = openAIClient.GetImageClient("gpt-image-1");

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

Console.WriteLine(imageGeneration.Value.ImageUri);

  2. Spusťte aplikaci pomocí příkazu dotnet run nebo tlačítka spustit v horní části Visual Studio:

    dotnet run

Výstup

Data obrázků zakódovaná v base64 se vytisknou do konzoly.

Důležité

GPT-image-1 a GPT-image-2 také podporují další parametry, jako quality jsou (low, medium, high), output_format (png, jpeg), background (auto, transparent) a output_compression (pouze 0-100, JPEG). Podrobnosti najdete v tématu Možnosti rozhraní API.

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu .

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Pomocí této příručky můžete začít generovat image pomocí sady Azure OpenAI SDK pro Java.

zdrojový kód Břery | Artifact (Maven) | Samples

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Nastavit

  1. Vytvořte novou složku image-quickstart a přejděte do složky rychlý start pomocí následujícího příkazu:

    mkdir image-quickstart && cd image-quickstart

  2. Nainstalujte Apache Maven. Pak spusťte a potvrďte mvn -v úspěšnou instalaci.

  3. V kořenovém adresáři projektu vytvořte nový pom.xml soubor a zkopírujte do něj následující kód:

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.azure.samples</groupId>
     <artifactId>quickstart-image-generation</artifactId>
     <version>1.0.0-SNAPSHOT</version>
     <build>
         <sourceDirectory>src</sourceDirectory>
         <plugins>
         <plugin>
             <artifactId>maven-compiler-plugin</artifactId>
             <version>3.7.0</version>
             <configuration>
             <source>1.8</source>
             <target>1.8</target>
             </configuration>
         </plugin>
         </plugins>
     </build>
     <dependencies>    
         <dependency>
             <groupId>com.azure</groupId>
             <artifactId>azure-ai-openai</artifactId>
             <version>1.0.0-beta.3</version>
         </dependency>
         <dependency>
             <groupId>com.azure</groupId>
             <artifactId>azure-core</artifactId>
             <version>1.53.0</version>
         </dependency>
         <dependency>
             <groupId>com.azure</groupId>
             <artifactId>azure-identity</artifactId>
             <version>1.15.1</version>
         </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>
             <version>1.7.9</version>
         </dependency>
     </dependencies>
 </project>

  4. Nainstalujte sadu Azure OpenAI SDK a závislosti.

    mvn clean dependency:copy-dependencies

  5. Pro potvěné ověřování bez klíčů pomocí Microsoft Entra ID se přihlaste k Azure pomocí následujícího příkazu:

    az login

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Spuštění aplikace

Ukázkový kód v tomto rychlém startu používá Microsoft Entra ID pro doporučené ověřování bez klíčů. Pokud dáváte přednost použití klíče rozhraní API, můžete objekt nahradit DefaultAzureCredential objektem AzureKeyCredential .

OpenAIAsyncClient client = new OpenAIClientBuilder()
    .endpoint(endpoint)
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildAsyncClient();

Podle těchto kroků vytvořte konzolovou aplikaci pro generování imagí.

  1. Ve stejném kořenovém adresáři projektu vytvořte nový soubor s názvem Quickstart.java .

  2. Do Quickstart.java zkopírujte následující kód:

    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;

public class Quickstart {

    public static void main(String[] args) throws InterruptedException {

        String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");

        // Use the recommended keyless credential instead of the AzureKeyCredential credential.

        OpenAIAsyncClient client = new OpenAIClientBuilder()
            .endpoint(endpoint)
            .credential(new DefaultAzureCredentialBuilder().build())
            .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 isn't a blocking call.
        // The thread sleeps so the program does not end before the send operation is complete. 
        // Use .block() instead of .subscribe() for a synchronous call.
        TimeUnit.SECONDS.sleep(10);
    }
}

  3. Spuštěním nové konzolové aplikace vygenerujte image:

    javac Quickstart.java -cp ".;target\dependency\*"
java -cp ".;target\dependency\*" Quickstart

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

Image location URL that provides temporary access to download the generated image is <SAS URL>.
Completed getImages.

Důležité

GPT-image-1 také podporuje další parametry, jako quality jsou (low, medium, high), output_format (png, jpeg), backgroundautotransparenta output_compression (0-100, pouze JPEG). Podrobnosti najdete v tématu Možnosti rozhraní API.

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu .

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Tento průvodce vám pomůže začít generovat image pomocí sady Azure OpenAI SDK pro JavaScript.

Dokumentace k Reference | Zdrojový kód | Package (npm) | Samples

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Instalace

  1. Vytvořte novou složku image-quickstart a přejděte do složky rychlý start pomocí následujícího příkazu:

    mkdir image-quickstart && cd image-quickstart

  2. Vytvořte následující package.json příkaz:

    npm init -y

  3. Nainstalujte klientskou knihovnu OpenAI pro JavaScript pomocí:

    npm install openai

  4. Pro doporučené ověřování bez hesla:

    npm install @azure/identity

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Pozor

Pokud chcete používat doporučené ověřování bez klíčů se sadou SDK, ujistěte se, že AZURE_OPENAI_API_KEY proměnná prostředí není nastavená.

Generování imagí

  1. index.js Vytvořte soubor s následujícím kódem:

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

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

// Required Azure OpenAI deployment name and API version
const apiVersion = process.env.OPENAI_API_VERSION || "2025-04-01-preview";
const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-image-1";

// 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://ai.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient() {
  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: "",
    quality: "high",
    // output_format: "png",  // "png" or "jpeg" (GPT-image-1 only)
    // background: "transparent",  // "auto" or "transparent" (GPT-image-1 only, requires PNG)
  });

  // GPT-image-1 models always return base64-encoded images
  for (const image of results.data) {
    const imageBuffer = Buffer.from(image.b64_json, "base64");
    fs.writeFileSync("generated_image.png", imageBuffer);
    console.log("Image saved to generated_image.png");
  }
}

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

  2. Přihlaste se k Azure pomocí následujícího příkazu:

    az login

  3. Spusťte javascriptový soubor.

    node index.js

Výstup

Vygenerovaný obrázek se uloží do generated_image.png aktuálního adresáře.

== Image Generation ==
Image saved to generated_image.png

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu .

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Tento průvodce vám pomůže začít generovat image pomocí sady Azure OpenAI SDK pro JavaScript.

Dokumentace k Reference | Zdrojový kód | Package (npm) | Samples

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Instalace

  1. Vytvořte novou složku image-quickstart a přejděte do složky rychlý start pomocí následujícího příkazu:

    mkdir image-quickstart && cd image-quickstart

  2. Vytvořte následující package.json příkaz:

    npm init -y

  3. package.json Aktualizujte na ECMAScript následujícím příkazem:

    npm pkg set type=module

  4. Nainstalujte klientskou knihovnu OpenAI pro JavaScript pomocí:

    npm install openai

  5. Pro doporučené ověřování bez hesla:

    npm install @azure/identity

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Pozor

Pokud chcete používat doporučené ověřování bez klíčů se sadou SDK, ujistěte se, že AZURE_OPENAI_API_KEY proměnná prostředí není nastavená.

Generování imagí

  1. index.ts Vytvořte soubor s následujícím kódem:

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

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

// Required Azure OpenAI deployment name and API version
const apiVersion = process.env.OPENAI_API_VERSION || "2025-04-01-preview";
const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-image-1";

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://ai.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: "",
    quality: "high",
    // output_format: "png",  // "png" or "jpeg" (GPT-image-1 only)
    // background: "transparent",  // "auto" or "transparent" (GPT-image-1 only, requires PNG)
  });

  // GPT-image-1 models always return base64-encoded images
  for (const image of results.data) {
    const imageBuffer = Buffer.from(image.b64_json!, "base64");
    fs.writeFileSync("generated_image.png", imageBuffer);
    console.log("Image saved to generated_image.png");
  }
}

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

  2. tsconfig.json Vytvořte soubor pro transpilování kódu TypeScript a zkopírujte následující kód pro ECMAScript.

    {
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

  3. Transpilovat z TypeScriptu do JavaScriptu.

    tsc

  4. Přihlaste se k Azure pomocí následujícího příkazu:

    az login

  5. Spusťte kód pomocí následujícího příkazu:

    node index.js

Výstup

Vygenerovaný obrázek se uloží do generated_image.png aktuálního adresáře.

== Image Generation ==
Image saved to generated_image.png

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu .

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Tento průvodce vám pomůže začít generovat image pomocí sady Azure OpenAI SDK for Go.

zdrojový kód Klibrary | Package | Samples

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Instalace

  1. Vytvořte novou složku dall-e-quickstart a přejděte do složky rychlý start pomocí následujícího příkazu:

    mkdir dall-e-quickstart && cd dall-e-quickstart

  2. Pro potvěné ověřování bez klíčů pomocí Microsoft Entra ID se přihlaste k Azure pomocí následujícího příkazu:

    az login

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Spuštění rychlého startu

Ukázkový kód v tomto rychlém startu používá Microsoft Entra ID pro doporučené ověřování bez klíčů. Pokud dáváte přednost použití klíče rozhraní API, můžete implementaci NewDefaultAzureCredentialNewKeyCredentialnahradit .

azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")
credential, err := azidentity.NewDefaultAzureCredential(nil)
client, err := azopenai.NewClient(azureOpenAIEndpoint, credential, nil)

Spuštění ukázky:

  1. Vytvořte nový soubor s názvem quickstart.go. Do souboru quickstart.go zkopírujte následující kód.

     package main

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

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

func main() {
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")
	modelDeploymentID := "gpt-image-1"

	credential, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Printf("ERROR: %s", err)
		return
	}

	client, err := azopenai.NewClient(
		azureOpenAIEndpoint, credential, nil)
	if err != nil {
		log.Printf("ERROR: %s", err)
		return
	}

	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),
		DeploymentName: to.Ptr(modelDeploymentID),
	}, nil)

	if err != nil {
		// Implement application specific error handling logic.
		log.Printf("ERROR: %s", err)
		return
	}

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

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

		if err != nil {
			// Implement application specific error handling logic.
			log.Printf("ERROR: %s", err)
			return
		}

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

  2. Spuštěním následujícího příkazu vytvořte nový modul Go:

     go mod init quickstart.go

  3. Spusťte go mod tidy instalaci požadovaných závislostí:

    go mod tidy

  4. Spuštěním následujícího příkazu spusťte ukázku:

     go run quickstart.go

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

Image generated, HEAD request on URL returned 200
Image URL: <SAS URL>

Důležité

Modely GPT-image-1 vždy místo adres URL vrací data obrázků s kódováním Base64. Pokud vaše verze sady SDK vrátí adresu URL pro DALL-E modely, musíte zpracovat odpověď base64 pro nasazení GPT-image-1. GPT-image-1 také podporuje další parametry, jako quality jsou (low, medium, high), output_format (png, jpeg), backgroundautotransparenta output_compression (0-100, pouze JPEG). Podrobnosti najdete v tématu Možnosti rozhraní API.

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu .

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

V této příručce můžete začít volat rozhraní API pro generování obrázků Azure OpenAI v Microsoft Rozhraní API generování obrázků Foundry Models pomocí PowerShellu.

Požadavky

požadavky na Microsoft Entra ID

Pro doporučené ověřování bez klíčů pomocí Microsoft Entra ID je potřeba:

  • Nainstalujte Azure CLI sloužící k ověřování bez klíčů pomocí Microsoft Entra ID.
  • Přiřaďte roli k uživatelskému Cognitive Services User účtu. Role můžete přiřadit na portálu Azure v části řízení Access (IAM)>Přidat přiřazení role.

Načtení informací o prostředcích

K ověření aplikace pomocí prostředku OpenAI Azure je potřeba načíst následující informace:

Název proměnné Hodnotu
AZURE_OPENAI_ENDPOINT Tuto hodnotu najdete v části Klíče a koncového bodu při zkoumání prostředku z portálu Azure.
AZURE_OPENAI_DEPLOYMENT_NAME Tato hodnota bude odpovídat vlastnímu názvu, který jste zvolili pro vaše nasazení při nasazení modelu. Tuto hodnotu najdete v části Resource Management>Model Deployments na portálu Azure.

Přečtěte si další informace o ověřování bez klíčů a nastavení proměnných prostředí.

Generování imagí

  1. Pro potvěné ověřování bez klíčů pomocí Microsoft Entra ID se přihlaste k Azure pomocí následujícího příkazu:

    az login

  2. Získejte Azure ověřovací token OpenAI a nastavte ho jako proměnnou prostředí pro aktuální relaci PowerShellu:

    $Env:DEFAULT_AZURE_CREDENTIAL_TOKEN = az account get-access-token --resource https://cognitiveservices.azure.com --query accessToken -o tsv

  3. Vytvořte nový soubor PowerShellu s názvem quickstart.ps1. Pak ho otevřete v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

  4. Obsah quickstart.ps1 nahraďte následujícím kódem. Ujistěte se, že AZURE_OPENAI_ENDPOINT je nastavená, a změňte hodnotu na upřednostňovaný prompt text.

    Pokud chcete místo ověřování bez klíčů použít ověřování pomocí klíče rozhraní API, nastavte AZURE_OPENAI_API_KEY a odkomentujte 'api-key' řádek.

     # Azure OpenAI metadata variables
 $openai = @{
     api_base    = $Env:AZURE_OPENAI_ENDPOINT 
     api_version = '2025-04-01-preview'
     deployment  = 'gpt-image-1' # the name of your GPT-image-1 series deployment
 }

 # Use the recommended keyless authentication via bearer token.
 $headers = [ordered]@{
     #'api-key' = $Env:AZURE_OPENAI_API_KEY
     'Authorization' = "Bearer $($Env:DEFAULT_AZURE_CREDENTIAL_TOKEN)"
 }

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

 # Adjust these values to fine-tune completions
 $body = [ordered]@{
     prompt = $prompt
     size   = '1024x1024'
     n      = 1
     quality = 'high'
     output_format = 'png'
     # background = 'transparent'  # 'auto' or 'transparent' (GPT-image-1 only; requires PNG output)
     # output_compression = 100    # 0-100 compression level (JPEG output only)
 } | ConvertTo-Json

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

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

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

 # Decode the base64 image and save to file
 $image_bytes = [Convert]::FromBase64String($response.data[0].b64_json)
 [IO.File]::WriteAllBytes($image_path, $image_bytes)
 return $image_path

    Důležité

    V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístup k vašim přihlašovacím údajům, jako je Správa tajných kódů PowerShellu s Azure Key Vault. Další informace o zabezpečení přihlašovacích údajů najdete v tomto článku zabezpečení .

  5. Spusťte skript pomocí PowerShellu:

    ./quickstart.ps1

    Skript vygeneruje obrázek a uloží ho.

Výstup

PowerShell vyžádá image z Azure OpenAI a uloží výstupní image do souboru generated_image.png ve vašem zadaném adresáři. Pro usnadnění je na konci skriptu vrácena úplná cesta k souboru.

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Pomocí této příručky můžete začít generovat obrázky pomocí Azure OpenAI v prohlížeči pomocí Microsoft Foundry.

Požadavky

Přejít na Foundry

Přejděte na Foundry a přihlaste se pomocí přihlašovacích údajů přidružených k vašemu prostředku Azure OpenAI. Během nebo po přihlášení vyberte příslušný adresář, Azure předplatné a Azure prostředek OpenAI.

Na cílové stránce Foundry vytvořte nebo vyberte nový projekt. V levém navigačním panelu přejděte na stránku Modely a koncové body . Vyberte Nasadit model a pak ze seznamu zvolte jeden z modelů generování imagí. Dokončete proces nasazení.

Na stránce modelu vyberte Otevřít v dětském hřišti.

Vyzkoušení generování imagí

Pomocí Images playground můžete začít zkoumat Azure funkce OpenAI bez kódu. Do textového pole zadejte výzvu k zadání obrázku a vyberte Generovat. Až bude image generovaná AI připravená, zobrazí se na stránce.

Poznámka

Rozhraní API pro obrázky mají filtr moderování obsahu. Pokud Azure OpenAI rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v tématu Filtrování obsahu.

V Images playground můžete také zobrazit ukázky kódu Python a cURL, které jsou předem vyplněné podle vašeho nastavení. Vyberte Zobrazit kód v horní části stránky. Tento kód můžete použít k napsání aplikace, která dokončí stejnou úlohu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Kvóty a omezení

Generování image má výchozí omezení rychlosti pro každé nasazení:

Model Výchozí kvóta (obrázky/min)
Řada GPT-image-1 5
GPT-image-2 5

Pokud chcete zobrazit aktuální kvótu nebo požádat o navýšení, přečtěte si téma Manage Azure kvót OpenAI.

Volání rozhraní API pro generování obrázků

Následující příkaz ukazuje nejzásadnější způsob použití modelu obrázku s kódem. Pokud se jedná o první použití těchto modelů prostřednictvím kódu programu, začněte rychlým startem.

Tip

Generování obrázků obvykle trvá 10 až 30 sekund v závislosti na nastavení modelu, velikosti a kvality.

Požadavky

Odešlete požadavek POST na:

https://<your_resource_name>.openai.azure.com/openai/deployments/<your_deployment_name>/images/generations?api-version=<api_version>

Adresa URL:

Nahraďte následující hodnoty:

  • <your_resource_name> je název vašeho prostředku Azure OpenAI.
  • <your_deployment_name> je název nasazení modelu.
  • <api_version> je verze rozhraní API, které chcete použít. Například 2025-04-01-preview.

Povinná záhlaví:

  • Content-Type: application/json
  • api-key: <your_API_key>

Text:

Následuje ukázkový text požadavku. Zadáte řadu možností definovaných v pozdějších částech.

{
    "prompt": "A multi-colored umbrella on the beach, disposable camera",
    "model": "gpt-image-1.5",
    "size": "1024x1024", 
    "n": 1,
    "quality": "high"
}

Tip

Informace o nákladech na token generování image najdete v tématu Tokeny image.

Výstup

Odpověď z úspěšného volání rozhraní API pro generování obrázků vypadá jako v následujícím příkladu. Pole b64_json obsahuje výstupní data obrázku.

{ 
    "created": 1698116662, 
    "data": [ 
        { 
            "b64_json": "<base64 image data>"
        }
    ]
}

Poznámka

Parametr response_format není podporován pro modely řady GPT-image-1, které vždy vracejí obrázky kódované podle base64.

Streaming

Streamování umožňuje přijímat částečné obrázky při jejich generování a poskytovat uživatelům rychlejší vizuální zpětnou vazbu. To je užitečné pro aplikace, u kterých chcete zobrazit průběh generování. Parametr partial_images (1–3) určuje, kolik zprostředkujících obrázků se vrátí před konečným výsledkem.

Žádosti o generování obrázků můžete streamovat do -series a gpt-image-2 modelů nastavením stream parametru partial_images na truehodnotu od 0 do gpt-image-13.

import base64
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://RESOURCE-NAME-HERE/openai/v1/",  
  api_key=token_provider,
)

stream = client.images.generate(
    model="gpt-image-1.5",
    prompt="A cute baby sea otter",
    n=1,
    size="1024x1024",
    stream=True,
    partial_images = 2
)

for event in stream:
    if event.type == "image_generation.partial_image":
        idx = event.partial_image_index
        image_base64 = event.b64_json
        image_bytes = base64.b64decode(image_base64)
        with open(f"river{idx}.png", "wb") as f:
            f.write(image_bytes)

Určení možností rozhraní API

Pro modely generování imagí jsou k dispozici následující parametry těla rozhraní API.

Velikost

U modelů řady GPT-image-1 zadejte velikost vygenerovaných obrázků jako jeden z 1024x1024, 1024x1536nebo 1536x1024. Čtvercové obrázky se generují rychleji.

Pro gpt-image-2libovolná řešení jsou podporována s následujícími omezeními:

  • Oba hrany musí být násobkem 16 pixelů.
  • Dlouhá hrana až 3840 px (podpora 4K).
  • Poměr stran až 3:1
  • Celkový počet pixelů mezi 655 360 a 8 294 400.

Kvality

Existují tři možnosti pro kvalitu obrázku: low, mediuma high. Obrázky s nižší kvalitou je možné generovat rychleji.

Výchozí hodnota je high.

Číslo

V jednom volání rozhraní API můžete vygenerovat jednu až 10 imagí. Výchozí hodnota je 1.

ID uživatele

Pomocí parametru uživatele zadejte jedinečný identifikátor uživatele, který požadavek provádí. Tento identifikátor je užitečný pro sledování a monitorování vzorů použití. Hodnota může být libovolný řetězec, například ID uživatele nebo e-mailová adresa.

Výstupní formát

Pomocí parametru output_format zadejte formát vygenerované image. Podporované formáty jsou PNG a JPEG. Výchozí hodnota je PNG.

Poznámka

Obrázky WEBP nejsou podporované v Azure OpenAI v modelech Microsoft Foundry.

Komprese

Pomocí parametru output_compression zadejte úroveň komprese pro vygenerovanou image. Zadejte celé číslo mezi 0 a , kde 0 není komprese a 100100je maximální komprese. Výchozí hodnota je 100.

Streaming

Pomocí parametru streamu povolte odpovědi streamování. Když nastavíte hodnotu true, rozhraní API vrátí částečné image při jejich vygenerování. Tato funkce poskytuje uživatelům rychlejší vizuální zpětnou vazbu a zlepšuje vnímanou latenci. Nastavte parametr partial_images , který určuje, kolik částečných obrázků se generuje (1–3).

Průhlednost

Nastavte parametr pozadí na transparent požadavek na vygenerování obrázku a output_formatPNG na získání obrázku s průhledným pozadím.

Volání rozhraní API pro úpravu obrázku

Rozhraní API pro úpravy obrázků umožňuje upravit existující obrázky na základě zadaných textových výzev. Volání rozhraní API je podobné volání rozhraní API pro generování image, ale musíte také zadat vstupní obrázek.

Důležité

Vstupní obrázek musí mít velikost menší než 50 MB a musí to být soubor PNG nebo JPG.

Odešlete požadavek POST na:

https://<your_resource_name>.openai.azure.com/openai/deployments/<your_deployment_name>/images/edits?api-version=<api_version>

Adresa URL:

Nahraďte následující hodnoty:

  • <your_resource_name> je název vašeho prostředku Azure OpenAI.
  • <your_deployment_name> je název nasazení modelu řady GPT-image.
  • <api_version> je verze rozhraní API, které chcete použít. Například 2025-04-01-preview.

Povinná záhlaví:

  • Content-Type: multipart/form-data
  • api-key: <your_API_key>

Text:

Následuje ukázkový text požadavku. Zadáte řadu možností definovaných v pozdějších částech.

Důležité

Rozhraní API pro úpravy obrázků přebírá data s více částmi nebo formuláři, nikoli data JSON. Následující příklad ukazuje ukázková data formuláře, která by byla připojena k požadavku cURL.

-F "image[]=@beach.png" \
-F 'prompt=Add a beach ball in the center' \
-F "model=gpt-image-1" \
-F "size=1024x1024" \
-F "n=1" \
-F "quality=high"

Výstup odpovědi rozhraní API

Odpověď z úspěšného volání rozhraní API pro úpravu obrázku vypadá jako v následujícím příkladu. Pole b64_json obsahuje výstupní data obrázku.

{ 
    "created": 1698116662, 
    "data": [ 
        { 
            "b64_json": "<base64 image data>"
        }
    ]
}

Určení možností rozhraní API pro úpravu obrázků

Následující parametry těla rozhraní API jsou k dispozici pro modely pro úpravy obrázků, kromě těch, které jsou k dispozici pro modely generování obrázků.

Obrázek

Hodnota obrázku označuje soubor obrázku , který chcete upravit.

Věrnost vstupu

Parametr input_fidelity určuje, kolik úsilí model vkládá do porovnávání stylu a funkcí, zejména obličejových prvků, vstupních obrázků.

Tento parametr umožňuje provádět drobné úpravy obrázku beze změny nesouvisejících oblastí. Při použití vysoké přesnosti vstupu se tváře zachovají přesněji než v standardním režimu.

Důležité

Model nepodporuje gpt-image-1-mini věrnost vstupu.

Maska

Parametr masky používá stejný typ jako vstupní parametr hlavního obrázku . Definuje oblast obrázku, kterou má model upravovat, pomocí plně průhledných pixelů (alfa nula) v těchto oblastech. Maska musí být soubor PNG a musí mít stejné rozměry jako vstupní obrázek.

Streaming

Pomocí parametru streamu povolte odpovědi streamování. Když nastavíte hodnotu true, rozhraní API vrátí částečné image při jejich vygenerování. Tato funkce poskytuje uživatelům rychlejší vizuální zpětnou vazbu a zlepšuje vnímanou latenci. Nastavte parametr partial_images , který určuje, kolik částečných obrázků se generuje (1–3).

Průhlednost

Pouze GPT-image-1: Nastavte parametr pozadí a transparentoutput_format na PNG požadavek na vygenerování obrázku, abyste získali obrázek s průhledným pozadím.

Psaní výzev k zápisu efektivního textu na obrázek

Výzvy by měly popisovat obsah, který chcete vidět na obrázku, a vizuální styl obrázku.

Při psaní výzev zvažte, že rozhraní API obrázků mají filtr moderování obsahu. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu.

Tip

Důkladný přehled o tom, jak můžete upravit textové výzvy k vygenerování různých druhů obrázků, najdete v průvodci technikou výzvy k zobrazení obrázku.

Zodpovědná generace umělé inteligence a image

Azure modely generování imagí OpenAI zahrnují integrované ochrany zodpovědné umělé inteligence (RAI), které pomáhají zajistit bezpečné a vyhovující použití.

Kromě toho Azure poskytuje moderování vstupu a výstupu ve všech modelech generování obrázků spolu s Azure konkrétními bezpečnostními opatřeními, jako je filtrování obsahu a monitorování zneužití. Tyto systémy pomáhají zjišťovat a bránit generování nebo zneužití škodlivého, nebezpečného nebo porušení zásad.

Zákazníci můžou získat další informace o těchto ochranných opatřeních a o tom, jak je přizpůsobit tady:

Zvláštní aspekty generování obrázků menších osob

Fotorealistické obrázky menších osob jsou ve výchozím nastavení blokované. Zákazníci můžou požádat o přístup k této funkci modelu. Zákazníci na podnikové úrovni se automaticky schválí.

Řešení potíží

Odmítnutí volání rozhraní API

Výzvy a obrázky se filtrují na základě našich zásad obsahu. Rozhraní API vrátí chybu při označení výzvy nebo obrázku.

Pokud je výzva označena příznakem, error.code hodnota ve zprávě je nastavena na contentFilterhodnotu . Tady je příklad:

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

Je také možné, že se vygenerovaná image filtruje. V tomto případě je chybová zpráva nastavena na Vygenerovaný obrázek byl filtrován v důsledku našeho bezpečnostního systému. Tady je příklad:

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

Chyby omezení rychlosti

Pokud se zobrazí chyba 429, překročili jste limit rychlosti. Počkejte, než se na portálu Azure znovu pokuste o navýšení kvóty.

Chyby ověřování

Pokud se zobrazí chyba 401:

  • Ověřování klíče rozhraní API: Ověřte správnost klíče rozhraní API a nevypršela jeho platnost.
  • Spravovaná identita: Ujistěte se, že vaše identita má v prostředku roli uživatele OpenAI služeb Cognitive Services .

Chyby časového limitu

Generování obrázků může trvat až 60 sekund u složitých výzev. Pokud dochází k vypršení časových limitů:

  • K získání částečných výsledků použijte streamování dříve.
  • Zjednodušte si výzvu.
  • Zkuste menší velikost obrázku.

Související obsah

  • Last updated on