> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# Como criar imagens e extrair dados com o Azure OpenAI e .NET
- URL: https://www.azurebrasil.cloud/blog/ccriar-e-extraindo-dados-de-imagens-com-azure-openai-e-net/
- Published: 2024-07-23T23:31:56.000Z
- Updated: 2024-07-24T12:48:15.000Z
- Author: Talles Valiatti

[Azure OpenAI](https://learn.microsoft.com/pt-br/azure/ai-services/openai/overview?ref=azurebrasil.cloud) é um serviço avançado da Microsoft que permite a integração de [modelos de IA ](https://learn.microsoft.com/pt-br/azure/ai-services/openai/concepts/models?ref=azurebrasil.cloud)em suas aplicações, proporcionando funcionalidades como geração de texto, tradução de idiomas, análise de sentimentos e mais. Uma das funcionalidades interessantes é a geração de imagens a partir de descrições textuais, utilizando a tecnologia [DALL-E](https://learn.microsoft.com/pt-br/azure/ai-services/openai/concepts/models?ref=azurebrasil.cloud#dall-e-models).

O gerador de imagens do Azure OpenAI, baseado no modelo DALL-E, permite criar imagens realistas a partir de descrições textuais. Isso pode ser extremamente útil para diversas aplicações, como marketing digital, design gráfico, educação, entre outras.

Vamos criar a pasta raiz do nosso projeto:

```markup
mkdir OpenAiImageGenerator
```

Em seguida, vamos criar o arquivo `.gitignore` para nossa solução:

```bash
dotnet new gitignore
```

Agora, criaremos uma [minimal Web API](https://learn.microsoft.com/en-us/aspnet/core/tutorials/min-web-api?view=aspnetcore-8.0&tabs=visual-studio&ref=azurebrasil.cloud):

```bash
dotnet new webapi
```

Precisamos adicionar o pacote NuGet para interagir com o Azure OpenAI:

```bash
dotnet add package Azure.AI.OpenAI --version 2.0.0-beta.2
```

Para utilizar o serviço Azure OpenAI, você precisa criar o recurso de nuvem correspondente e fazer o *deploy* de um modelo de geração de imagens. Para isso, siga os guias abaixo:

- [Como criar o recurso no Azure](https://learn.microsoft.com/pt-br/azure/ai-services/openai/how-to/create-resource?pivots=web-portal&ref=azurebrasil.cloud)
- [Guia rápido do DALL-E](https://learn.microsoft.com/en-us/azure/ai-services/openai/dall-e-quickstart?tabs=dalle3%2Ccommand-line&pivots=programming-language-studio&ref=azurebrasil.cloud#prerequisites)

Adicione as configurações ao arquivo `appsettings.json` da sua Web API:

```json
"AzureOpenAi": {
    "Endpoint": "<your-endpoint>",
    "Key": "<your-key>",
    "ImageModel": "<your-image-generator-model>"
  }
  
```

Vamos criar o modelo de requisição para gerar uma imagem:

```csharp
namespace OpenAiImageGenerator.Services.Models;

public record CreateImageRequest(string GeneralIdea);
```

E o modelo que será retornado pela nossa API:

```csharp
namespace OpenAiImageGenerator.Services.Models;

public record ImageResult(string Url);
```

Agora, vamos criar o serviço para trabalhar com as imagens:

```csharp
using OpenAiImageGenerator.Services.Models;

namespace OpenAiImageGenerator.Services;

public interface IImageService
{
    Task<ImageResult> CreateImageAsync(CreateImageRequest request);
}
```

```csharp
using Azure;
using Azure.AI.OpenAI;
using OpenAI.Images;
using OpenAiImageGenerator.Services.Models;

namespace OpenAiImageGenerator.Services;

public class AzureOpenAiImageService(IConfiguration configuration) : IImageService
{
    private ImageClient GetImageClient()
    {
        string endpoint = configuration["AzureOpenAi:Endpoint"]!;
        string key = configuration["AzureOpenAi:Key"]!;

        AzureOpenAIClient azureClient = new(new Uri(endpoint), new AzureKeyCredential(key));
        
        return azureClient.GetImageClient(configuration["AzureOpenAi:ImageModel"]!);
    }

    public async Task<ImageResult> CreateImageAsync(CreateImageRequest request)
    {
        var client = GetImageClient();
        
        var image = await client.GenerateImageAsync(
            request.GeneralIdea,
            new ImageGenerationOptions
            { 
                Quality = GeneratedImageQuality.Standard, 
                Size = GeneratedImageSize.W1024xH1024,
                Style = GeneratedImageStyle.Vivid,
                ResponseFormat = GeneratedImageFormat.Uri,
            }
        );

        return new ImageResult(image.Value!.ImageUri.ToString());
    }
}
```

Precisamos ainda configurar a [injeção do dependência](https://learn.microsoft.com/pt-br/dotnet/core/extensions/dependency-injection?ref=azurebrasil.cloud) do serviço criado no `Program.cs`:

```csharp
builder.Services.AddScoped<IImageService, AzureOpenAiImageService>();
```

Vamos implementar o endpoint para expor o serviço de criação de imagem:

```csharp
app.MapPost("/image", async (CreateImageRequest request, IImageService service)
                => await service.CreateImageAsync(request))
.WithName("CreateImage")
.WithOpenApi();
```

O `Program.cs` ficou dessa forma:

```csharp
using OpenAiImageGenerator.Services;
using OpenAiImageGenerator.Services.Models;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IImageService, AzureOpenAiImageService>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();

app.UseHttpsRedirection();

app.MapPost("/image", async (CreateImageRequest request, IImageService service)
                => await service.CreateImageAsync(request))
.WithName("CreateImage")
.WithOpenApi();

app.Run();
```

Para testar, e execute a aplicação `dotnet run` envie a seguinte requisição:

```json
{
  "generalIdea": "A dog coding in his laptop. He is also eating a cheese pizza"
}
```

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/07/Screen-Shot-2024-07-23-at-15.42.56.png)

Temos a reposta com a URL da imagem gerada!

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/07/Screen-Shot-2024-07-23-at-15.42.39.png)

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/07/Screen-Shot-2024-07-23-at-15.45.11.png)

Tudo ocorreu bem! Vamos agora criar um endpoint que irá receber a URL da imagem e irá descrevê-la. Para isso, adicionaremos uma nova chave no `appsettings.json`:

```json
"ChatModel": "<your-chat-model>"
```

Nesse caso, estou utilizando o[ GPT-4o](https://learn.microsoft.com/pt-br/azure/ai-services/openai/concepts/models?ref=azurebrasil.cloud#gpt-4o-and-gpt-4-turbo)! Leia esse [artigo para mais informações](https://learn.microsoft.com/pt-br/azure/ai-services/openai/concepts/models?ref=azurebrasil.cloud#gpt-4-and-gpt-4-turbo-models).

Vamos criar um novo [*record*](https://learn.microsoft.com/pt-br/dotnet/csharp/language-reference/builtin-types/record?ref=azurebrasil.cloud) de entrada:

```csharp
namespace OpenAiImageGenerator.Services.Models;

public record DescribeImageRequest(string Url);
```

E um novo *record* de saída:

```csharp
namespace OpenAiImageGenerator.Services.Models;

public record DescribeImageResult(string Description);
```

Adicione o novo método no serviço de imagens:

```csharp
Task<DescribeImageResult> DescribeImageAsync(DescribeImageRequest request);
```

```csharp
 private ChatClient GetChatClient()
    {
        string endpoint = configuration["AzureOpenAi:Endpoint"]!;
        string key = configuration["AzureOpenAi:Key"]!;

        AzureOpenAIClient azureClient = new(new Uri(endpoint), new AzureKeyCredential(key));
        
        return azureClient.GetChatClient(configuration["AzureOpenAi:ChatModel"]!);
    }
```

```csharp
  public async Task<DescribeImageResult> DescribeImageAsync(DescribeImageRequest request)
    {
        var client = GetChatClient();

        ChatMessageContentPart[] content =
        [
            ChatMessageContentPart.CreateImageMessageContentPart(new Uri(request.Url))
        ];
        
        ChatCompletion completion = await client.CompleteChatAsync(
        [
            new SystemChatMessage("You are a helpful assistant that create image descriptions"),
            new UserChatMessage(content)
        ]);

        var result = completion.Content[0].Text;
        
        return new DescribeImageResult(result);
    }
```

Com o novo método pronto, podemos criar o novo *endpoint* no `Program.cs`:

```csharp
app.MapPost("/image/describe", async (DescribeImageRequest request, IImageService service)
        => await service.DescribeImageAsync(request))
    .WithName("DescribeImage")
    .WithOpenApi();
```

```csharp
app.MapPost("/image/describe", async (DescribeImageRequest request, IImageService service)
        => await service.DescribeImageAsync(request))
    .WithName("DescribeImage")
    .WithOpenApi();
```

Vamos fazer a requisição utilizando a URL da imagem retornada anteriormente e obter a resposta descrevendo a imagem:

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/07/Screen-Shot-2024-07-23-at-16.13.49.png)

Resultado:

```json
{
  "description": "The image depicts a golden retriever sitting in a cozy, leather armchair in a warmly lit room with a brick wall and bookshelves. The dog is engaged with a laptop on a wooden table, appearing to type with one paw while holding a slice of pepperoni pizza in its mouth. On the table in front of the dog, there's an open pizza box with a whole pepperoni pizza inside. A lamp with a beige shade provides soft lighting. The scene is playful and humorous, suggesting the dog is busy multitasking while enjoying its meal."
}
```

E é isso pessoal!

Você já pode baixar o projeto por esse [link](https://github.com/TallesValiatti/OpenAiImageGenerator?ref=azurebrasil.cloud), e não esquece de me seguir no [LinkedIn](https://www.linkedin.com/in/tallesvaliatti/?ref=azurebrasil.cloud)!

Até a próxima, abraços!