Início Rápido: Analisar o conteúdo da imagem

Pré-requisitos

• Uma conta do Azure. Se não tiver uma, pode criar uma gratuitamente.
• Um recurso de IA do Azure.

Configuração

Siga estas etapas para usar a página de Segurança de Conteúdo experimente:

1. Vá para Azure AI Foundry e navegue até seu projeto/hub. Em seguida, selecione a guia Guardrails + controls no painel de navegação esquerdo e selecione a guia Experimente .
2. Na página Experimente , você pode experimentar vários recursos de controles e guarda-corpos, como conteúdo de texto e imagem, usando limites ajustáveis para filtrar conteúdo impróprio ou prejudicial.

Captura de ecrã da página de experimentação de Guardrails & controlos.

Analise imagens

A página Moderar imagem permite que você experimente rapidamente a moderação de imagem.

1. Selecione o painel Moderar conteúdo da imagem.
2. Selecione uma imagem de exemplo nos painéis da página ou carregue a sua própria imagem.
3. Selecione Executar teste. O serviço retorna todas as categorias que foram detetadas, com o nível de gravidade para cada uma: 0-Seguro, 2-Baixo, 4-Médio, 6-Alto. Ele também retorna um resultado binário Aceito/Rejeitado , com base nos filtros que você configurar. Use a matriz na guia Configurar filtros à direita para definir seus níveis de gravidade permitidos/proibidos para cada categoria. Em seguida, você pode executar o texto novamente para ver como o filtro funciona.

Ver e exportar código

Você pode usar a funcionalidade Ver Código nas páginas Analisar conteúdo de texto ou Analisar conteúdo de imagem para visualizar e copiar o código de exemplo, que inclui configuração para filtragem por nível de gravidade, listas de bloqueio e funções de moderação. Em seguida, pode implantar o código no seu ambiente.

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois de terminar, selecione ir para o recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.
• cURL instalado

Analisar conteúdo de imagem

A seção a seguir apresenta uma solicitação de moderação de imagem de exemplo com cURL.

Preparar uma imagem de exemplo

Escolha uma imagem de exemplo para analisar e transfira-a para o seu dispositivo.

Consulte Requisitos de entrada para as limitações de imagem. Se o seu formato for animado, o serviço extrairá o primeiro quadro para fazer a análise.

Você pode inserir sua imagem por um dos dois métodos: fluxo de arquivos local ou URL de armazenamento de blob.

• Filestream local (recomendado): Codifique a sua imagem para base64. Você pode usar um site como codebeautify para fazer a codificação. Em seguida, salve a cadeia de caracteres codificada em um local temporário.

• URL de armazenamento de Blob: carregue a sua imagem numa conta de Armazenamento de Blob do Azure. Siga o guia de início rápido de armazenamento de blob para aprender como fazer isso. Em seguida, abra o Gerenciador de Armazenamento do Azure e obtenha a URL para sua imagem. Salve-o em um local temporário.

  Em seguida, você precisa conceder ao seu recurso de Segurança de Conteúdo acesso para ler o recurso de Armazenamento do Azure. Ative a identidade gerida pelo sistema para a instância de Segurança de Conteúdo do Azure AI e atribua à identidade a função de Contribuidor/Proprietário de Dados de Armazenamento Blob.

  Importante

  Apenas as funções de Colaborador de Dados de Blob de Armazenamento ou Proprietário de Dados de Blob de Armazenamento são válidas para continuar.

  1. Habilite a identidade gerenciada para a instância de Segurança de Conteúdo do Azure AI.

     

  2. Atribua a função de Contribuidor/Proprietário de Dados de Blob de Armazenamento à identidade gerenciada. Quaisquer funções destacadas abaixo devem funcionar.

     

     

     

Analisar conteúdo de imagem

Cole o comando abaixo em um editor de texto e faça as seguintes alterações.

1. Substitua <endpoint> pelo URL do ponto de extremidade do recurso.
2. Substitua <your_subscription_key> pela sua chave.
3. Preencha o campo "image" no corpo com um campo "content" ou "blobUrl". Por exemplo: {"image": {"content": "<base_64_string>"} ou {"image": {"blobUrl": "<your_storage_url>"}.

curl --location --request POST '<endpoint>/contentsafety/image:analyze?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <your_subscription_key>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "image": {
    "content": "<base_64_string>"
  },
  "categories": ["Hate", "SelfHarm", "Sexual", "Violence"],
  "outputType": "FourSeverityLevels"
}'

{
  "image": {
    "blobUrl": "<your_storage_url>"
  }
}

Os campos abaixo devem ser incluídos no URL:

Os parâmetros no corpo da solicitação são definidos nesta tabela:

Abra uma janela de prompt de comando e execute o comando cURL.

Saída

Você deve ver os resultados da moderação de imagem exibidos como dados JSON no console. Por exemplo:

{
  "categoriesAnalysis": [
    {
      "category": "Hate",
      "severity": 2
    },
    {
      "category": "SelfHarm",
      "severity": 0
    },
    {
      "category": "Sexual",
      "severity": 0
    },
    {
      "category": "Violence",
      "severity": 0
    }
  ]
}

Os campos JSON na saída são definidos aqui:

Documentação de referência | Código-fonte da biblioteca | Pacote (NuGet) | Amostras

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• A IDE do Visual Studio com a carga de trabalho de desenvolvimento de desktop .NET habilitada. Ou, se você não planeja usar o IDE do Visual Studio, precisará da versão atual do .NET Core.
• .NET Runtime instalado.
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois que terminar, selecione ir para recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.

Configurar a aplicação

Crie um novo aplicativo C#.

dotnet new console -n content-safety-quickstart

dotnet build

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

dotnet add package Azure.AI.ContentSafety

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

• Para definir a CONTENT_SAFETY_KEY variável de ambiente, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do seu recurso.
• Para definir a variável de CONTENT_SAFETY_ENDPOINT ambiente, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do seu recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo de imagem

No diretório do projeto, abra o arquivo de Program.cs que foi criado anteriormente. Cole o código seguinte.

using System;
using Azure.AI.ContentSafety;

namespace Azure.AI.ContentSafety.Dotnet.Sample
{
  class ContentSafetySampleAnalyzeImage
  {
    public static void AnalyzeImage()
    {
      // retrieve the endpoint and key from the environment variables created earlier
      string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
      string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");

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

      // Example: analyze image

      string imagePath = @"sample_data\image.png";
      ContentSafetyImageData image = new ContentSafetyImageData(BinaryData.FromBytes(File.ReadAllBytes(imagePath)));

      var request = new AnalyzeImageOptions(image);

      Response<AnalyzeImageResult> response;
      try
      {
          response = client.AnalyzeImage(request);
      }
      catch (RequestFailedException ex)
      {
          Console.WriteLine("Analyze image failed.\nStatus code: {0}, Error code: {1}, Error message: {2}", ex.Status, ex.ErrorCode, ex.Message);
          throw;
      }

      Console.WriteLine("Hate severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Hate)?.Severity ?? 0);
      Console.WriteLine("SelfHarm severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.SelfHarm)?.Severity ?? 0);
      Console.WriteLine("Sexual severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Sexual)?.Severity ?? 0);
      Console.WriteLine("Violence severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Violence)?.Severity ?? 0);
    }
    static void Main()
    {
      AnalyzeImage();
    }
  }
}

Crie uma pasta sample_data no diretório do projeto e adicione um arquivo image.png a ela.

dotnet build
dotnet run

Documentação de referência | Código-fonte da biblioteca | Pacote (PyPI) | Amostras |

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois que terminar, selecione ir para recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.
• Python 3.8 ou posterior
  • Sua instalação do Python deve incluir pip. Você pode verificar se você tem pip instalado executando pip --version na linha de comando. Obtenha o pip ao instalar a versão mais recente do Python.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

• Para definir a CONTENT_SAFETY_KEY variável de ambiente, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do seu recurso.
• Para definir a variável de CONTENT_SAFETY_ENDPOINT ambiente, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do seu recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo de imagem

A seção a seguir percorre uma solicitação de exemplo com o SDK do Python.

1. Abra um prompt de comando, navegue até a pasta do projeto e crie um novo arquivo chamado quickstart.py.

2. Execute este comando para instalar a biblioteca de cliente do Azure AI Content Safety:

   python -m pip install azure-ai-contentsafety
   

3. Copie o seguinte código para quickstart.py:

   import os
   
   from azure.ai.contentsafety import ContentSafetyClient
   from azure.ai.contentsafety.models import AnalyzeImageOptions, ImageData, ImageCategory
   from azure.core.credentials import AzureKeyCredential
   from azure.core.exceptions import HttpResponseError
   
   def analyze_image():
       endpoint = os.environ.get('CONTENT_SAFETY_ENDPOINT')
       key = os.environ.get('CONTENT_SAFETY_KEY')
       image_path = os.path.join("sample_data", "image.jpg")
   
       # Create an Azure AI Content Safety client
       client = ContentSafetyClient(endpoint, AzureKeyCredential(key))
   
   
       # Build request
       with open(image_path, "rb") as file:
           request = AnalyzeImageOptions(image=ImageData(content=file.read()))
   
       # Analyze image
       try:
           response = client.analyze_image(request)
       except HttpResponseError as e:
           print("Analyze image failed.")
           if e.error:
               print(f"Error code: {e.error.code}")
               print(f"Error message: {e.error.message}")
               raise
           print(e)
           raise
   
       hate_result = next(item for item in response.categories_analysis if item.category == ImageCategory.HATE)
       self_harm_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SELF_HARM)
       sexual_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SEXUAL)
       violence_result = next(item for item in response.categories_analysis if item.category == ImageCategory.VIOLENCE)
   
       if hate_result:
           print(f"Hate severity: {hate_result.severity}")
       if self_harm_result:
           print(f"SelfHarm severity: {self_harm_result.severity}")
       if sexual_result:
           print(f"Sexual severity: {sexual_result.severity}")
       if violence_result:
           print(f"Violence severity: {violence_result.severity}")
   
   if __name__ == "__main__":
       analyze_image()
   

4. Substitua "sample_data" e "image.jpg" pelo caminho e nome do arquivo do local que você deseja usar.

5. Em seguida, execute o aplicativo com o python comando em seu arquivo de início rápido.

   python quickstart.py
   

Documentação de referência | Código fonte da biblioteca | Artefacto (Maven) | Amostras

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• A versão atual do Java Development Kit (JDK)
• A ferramenta de compilação Gradle ou outro gerenciador de dependência.
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois que terminar, selecione ir para recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.

Configurar a aplicação

Crie um novo projeto Gradle.

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue para a mesma.

mkdir myapp && cd myapp

Executar o comando gradle init no seu diretório de trabalho. Este comando criará arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, selecione Kotlin.

No diretório de trabalho, execute o seguinte comando para criar uma pasta de origem do projeto:

mkdir -p src/main/java

Navegue até a nova pasta e crie um arquivo chamado ContentSafetyQuickstart.java.

Crie também uma src/resources pasta na raiz do seu projeto e adicione uma imagem de exemplo a ela.

Instalar o SDK do cliente

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

Localize build.gradle.kts e abra-o com o seu IDE ou editor de texto preferido. Em seguida, copie a seguinte configuração de compilação. Esta configuração define o projeto como uma aplicação Java cujo ponto de entrada é a classe ContentSafetyQuickstart. Ele importa a biblioteca do Azure AI Vision.

plugins {
    java
    application
}
application { 
    mainClass.set("ContentSafetyQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-contentsafety", version = "1.0.0")
}

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

• Para definir a CONTENT_SAFETY_KEY variável de ambiente, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do seu recurso.
• Para definir a variável de CONTENT_SAFETY_ENDPOINT ambiente, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do seu recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo de imagem

Abra ContentSafetyQuickstart.java em seu editor ou IDE preferido e cole no código a seguir. Substitua a variável source pelo caminho para a imagem de exemplo.

import com.azure.ai.contentsafety.ContentSafetyClient;
import com.azure.ai.contentsafety.ContentSafetyClientBuilder;
import com.azure.ai.contentsafety.models.AnalyzeImageOptions;
import com.azure.ai.contentsafety.models.AnalyzeImageResult;
import com.azure.ai.contentsafety.models.ContentSafetyImageData;
import com.azure.ai.contentsafety.models.ImageCategoriesAnalysis;
import com.azure.core.credential.KeyCredential;
import com.azure.core.util.BinaryData;
import com.azure.core.util.Configuration;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;


public class ContentSafetyQuickstart {
    public static void main(String[] args) throws IOException {

        // get endpoint and key from environment variables
        String endpoint = System.getenv("CONTENT_SAFETY_ENDPOINT");
        String key = System.getenv("CONTENT_SAFETY_KEY");

        ContentSafetyClient contentSafetyClient = new ContentSafetyClientBuilder()
            .credential(new KeyCredential(key))
            .endpoint(endpoint).buildClient();

        ContentSafetyImageData image = new ContentSafetyImageData();
        String cwd = System.getProperty("user.dir");
        String source = "/src/samples/resources/image.png";

        image.setContent(BinaryData.fromBytes(Files.readAllBytes(Paths.get(cwd, source))));

        AnalyzeImageResult response =
                contentSafetyClient.analyzeImage(new AnalyzeImageOptions(image));

        for (ImageCategoriesAnalysis result : response.getCategoriesAnalysis()) {
            System.out.println(result.getCategory() + " severity: " + result.getSeverity());
        }
    }
}

Navegue de volta para a pasta raiz do projeto e crie o aplicativo com:

gradle build

Em seguida, execute-o com o gradle run comando:

gradle run

Saída

Hate severity: 0
SelfHarm severity: 0
Sexual severity: 0
Violence severity: 0

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

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• A versão atual do Node.js
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois que terminar, selecione ir para recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.

Configurar a aplicação

Crie um novo aplicativo Node.js. Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue para a mesma.

mkdir myapp && cd myapp

Execute o comando npm init para criar uma aplicação Node.js com um ficheiro package.json.

npm init

Crie também uma /resources pasta na raiz do seu projeto e adicione uma imagem de exemplo a ela.

Instalar o SDK do cliente

Instale o @azure-rest/ai-content-safety pacote npm:

npm install @azure-rest/ai-content-safety

Instale também o módulo dotenv para usar variáveis de ambiente.

npm install dotenv

O ficheiro package.json da sua aplicação será atualizado com as dependências.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

• Para definir a CONTENT_SAFETY_KEY variável de ambiente, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do seu recurso.
• Para definir a variável de CONTENT_SAFETY_ENDPOINT ambiente, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do seu recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo de imagem

Crie um novo arquivo em seu diretório, index.js. Abra-o no seu editor ou IDE preferido e cole no código a seguir. Substitua a variável image_path pelo caminho para a imagem de exemplo.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");
const fs = require("fs");
const path = require("path");

// Load the .env file if it exists
require("dotenv").config();

async function main() {
    // get endpoint and key from environment variables
    const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"];
    const key = process.env["CONTENT_SAFETY_KEY"];
    
    const credential = new AzureKeyCredential(key);
    const client = ContentSafetyClient(endpoint, credential);
    
    // replace with your own sample image file path 
    const image_path = path.resolve(__dirname, "./resources/image.jpg");
    
    const imageBuffer = fs.readFileSync(image_path);
    const base64Image = imageBuffer.toString("base64");
    const analyzeImageOption = { image: { content: base64Image } };
    const analyzeImageParameters = { body: analyzeImageOption };
    
    const result = await client.path("/image:analyze").post(analyzeImageParameters);
    
    if (isUnexpected(result)) {
        throw result;
    }
    for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const imageCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(
      imageCategoriesAnalysisOutput.category,
      " severity: ",
      imageCategoriesAnalysisOutput.severity
    );
  }
}

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

Execute a aplicação com o comando node no seu ficheiro de início rápido.

node index.js

Saída

Hate severity:  0
SelfHarm severity:  0
Sexual severity:  0
Violence severity:  0

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

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• Node.js LTS
• TypeScript
• Código do Visual Studio
• Depois de ter a sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter a sua chave e ponto de extremidade. Introduza um nome exclusivo para o seu recurso, selecione a sua subscrição e selecione um grupo de recursos, uma região suportada (consulte Disponibilidade da região) e um escalão de preços suportado. Depois, selecione Criar.
  • O recurso leva alguns minutos para ser implantado. Depois que terminar, selecione ir para recurso. No painel esquerdo, sob Gestão de Recursos, selecione Chave de Subscrição e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar APIs.

Criar um ambiente de desenvolvimento local

1. Crie um novo diretório para seu projeto e navegue até ele:

   mkdir content-safety-image-analysis
   cd content-safety-image-analysis
   code .
   

2. Crie um novo pacote para módulos ESM no diretório do projeto:

   npm init -y
   npm pkg set type=module
   

3. Instale os pacotes necessários:

   npm install @azure-rest/ai-content-safety
   

4. Instale dependências de desenvolvimento:

   npm install typescript @types/node --save-dev
   

5. Crie um tsconfig.json arquivo no diretório do projeto:

   {
     "compilerOptions": {
       "target": "es2022",
       "module": "esnext",
       "moduleResolution": "bundler",
       "rootDir": "./src",
       "outDir": "./dist/",
       "esModuleInterop": true,
       "forceConsistentCasingInFileNames": true,
       "strict": true,
       "skipLibCheck": true,
       "declaration": true,
       "sourceMap": true,
       "resolveJsonModule": true,
       "moduleDetection": "force",
       "allowSyntheticDefaultImports": true,
       "verbatimModuleSyntax": false
     },
     "include": [
       "src/**/*.ts"
     ],
     "exclude": [
       "node_modules/**/*",
       "**/*.spec.ts"
     ]
   }
   

6. Atualize package.json para incluir um script para criar arquivos TypeScript:

   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js"
   }
   

7. Crie uma resources pasta e adicione uma imagem de exemplo a ela.

8. Crie um src diretório para seu código TypeScript.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

• Para definir a CONTENT_SAFETY_KEY variável de ambiente, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do seu recurso.
• Para definir a variável de CONTENT_SAFETY_ENDPOINT ambiente, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do seu recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo de imagem

Crie um novo arquivo em seu src diretório index.ts e cole no código a seguir. Substitua a cadeia de caracteres usada para criar a imagePath variável pelo caminho para a imagem de exemplo.

import ContentSafetyClient, {
    isUnexpected,
    AnalyzeImageParameters,
    AnalyzeImage200Response,
    AnalyzeImageDefaultResponse,
    AnalyzeImageOptions,
    ImageCategoriesAnalysisOutput
} from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";
import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from "url";

// Create __dirname equivalent for ESM modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Get endpoint and key from environment variables
const endpoint = process.env.CONTENT_SAFETY_ENDPOINT;
const key = process.env.CONTENT_SAFETY_KEY;

if (!endpoint || !key) {
    throw new Error("Missing required environment variables CONTENT_SAFETY_ENDPOINT or CONTENT_SAFETY_KEY");
}

try {

    const credential = new AzureKeyCredential(key);
    const client = ContentSafetyClient(endpoint, credential);

    const imagePath = path.join(__dirname, '../resources/image.jpg');

    const imageBuffer = fs.readFileSync(imagePath);
    const base64Image = imageBuffer.toString("base64");
    const analyzeImageOption: AnalyzeImageOptions = { image: { content: base64Image } };
    const analyzeImageParameters: AnalyzeImageParameters = { body: analyzeImageOption };

    const result: AnalyzeImage200Response | AnalyzeImageDefaultResponse = await client.path("/image:analyze").post(analyzeImageParameters);

    if (isUnexpected(result)) {
        throw result;
    }

    const categoriesAnalysis = result.body.categoriesAnalysis as ImageCategoriesAnalysisOutput[];

    for (const analysis of categoriesAnalysis) {
        console.log(`${analysis.category} severity: ${analysis.severity}`);
    }
} catch (error) {
    console.error("Error analyzing image:", error);
}

Criar e executar o exemplo

1. Compile o código TypeScript:

   npm run build
   

2. Execute o JavaScript compilado:

   node dist/index.js
   

Saída

Hate severity:  0
SelfHarm severity:  0
Sexual severity:  0
Violence severity:  0