Instalar e executar contêineres

Este conteúdo se aplica a: v3.0 (GA) v3.1 (GA)

A IA do Azure para Informação de Documentos é um serviço de IA do Azure que permite criar um software de processamento de dados automatizado utilizando a tecnologia de aprendizado de máquina. A Informação de Documentos habilita você a identificar e extrair texto, pares de chave-valor, marcas de seleção, dados de tabela e muito mais dos seus documentos. Os resultados são gerados em dados estruturados que ../incluem as relações no arquivo original. Os contêineres processam apenas os dados fornecidos a eles e utilizam exclusivamente os recursos que têm permissão para acessar. Os contêineres não podem processar dados de outras regiões.

Neste artigo, você aprenderá como fazer download, instalar e executar contêineres do Informação de Documentos. Os contêineres habilitam a execução do serviço Informação de Documentos em seu próprio ambiente. Contêineres são excelentes para especificar requisitos de segurança e governança de dados.

• Os modelos de leitura, layout, documento de identificação, recibo e fatura são compatíveis com contêineres da Informação de Documentos v3.1.

• Os modelos de leitura, layout, documento geral, cartão de visita e personalizado são compatíveis com contêineres da Informação de Documentos v3.0.

Suporte à versão

Atualmente, o suporte de contêineres está disponível na versão v3.0: 2022-08-31 (GA) da Informação de Documentos para todos os modelos e v3.1 2023-07-31 (GA) nos modelos de leitura, layout, fatura, recibo e documento de identificação:

• API REST v3.0: 2022-08-31 (GA)
• API REST v3.1: 2023-07-31 (GA)
• Direcionamento de bibliotecas de cliente REST API v3.0: 2022-08-31 (GA)
• Direcionamento de bibliotecas de cliente REST API v3.1: 2023-07-31 (GA)

Pré-requisitos

Para começar, você precisa de uma conta do Azure. Se você não tem uma, crie uma conta gratuita.

Também é necessário o seguinte para utilizar os contêineres de Informações de Documentos:

Obrigatório	Finalidade
Familiaridade com o Docker	É necessário ter uma compreensão básica de conceitos do Docker, como registros, repositórios, contêineres e imagens de contêiner, bem como conhecimento básico de docker terminologia e comandos.
Mecanismo do Docker instalado	É necessário ter o Mecanismo Docker instalado em um computador host. O Docker fornece pacotes que configuram o ambiente do Docker no macOS, no Windows e no Linux. Para instruções sobre conceitos básicos do Docker e de contêiner, consulte a visão geral do Docker. O Docker deve ser configurado para permitir que os contêineres conectem-se e enviem dados de cobrança para o Azure. No Windows, o Docker também deve ser configurado para dar suporte a contêineres do Linux.
Recurso de Informação de Documentos	Um serviço único de IA do Azure para Informação de Documentos ou um recurso de vários serviços no portal do Microsoft Azure. Para usar os contêineres, você deve ter a chave associada e o URI do ponto de extremidade. Ambos os valores estão disponíveis na página Informação de Documentos Chaves e Pontos de Extremidade do portal do Azure: {FORM_RECOGNIZER_KEY} : uma das duas chaves de recursos disponíveis. {FORM_RECOGNIZER_ENDPOINT_URI} : o ponto de extremidade para o recurso usado para rastrear informações de cobrança.

Opcional	Finalidade
CLI do Azure (Interface de linha de comando do Azure)	O CLI do Azure permite que você use um conjunto de comandos online para criar e gerenciar recursos do Azure. Ela está disponível para instalação em ambientes Windows, macOS e Linux e pode ser executada em um contêiner do Docker e no Azure Cloud Shell.

Requisitos do computador host

O host é um computador baseado em x64 que executa o contêiner do Docker. Ele pode ser um computador local ou um serviço de hospedagem do Docker no Azure, como:

• Serviço de Kubernetes do Azure.
• Instâncias de Contêiner do Azure.
• Um cluster do Kubernetes implantado no Azure Stack. Para obter mais informações, consulte Implantar Kubernetes no Azure Stack.

Observação

Observe que o contêiner do Estúdio não pode ser implantado e executado no Serviço de Kubernetes do Azure. O contêiner do Estúdio só tem suporte para execução no computador local.

Recomendações e requisitos do contêiner

Contêineres de suporte são necessários

A tabela a seguir lista um ou mais contêineres com suporte para cada contêiner de Informação de Documentos que você baixar. Para saber mais, confira a seção Cobrança.

Contêiner de recursos	Contêineres de suporte
Leitura	Não é necessária
Layout	Não é necessária
Cartão de visita	Leitura
Documento geral	Layout
Fatura	Layout
Receipt	Leitura ou Layout
Documento de identificação	Leitura
Template Personalizado	Layout

Memória e núcleos de CPU recomendados

Observação

Os valores mínimos e recomendados se baseiam nos limites do Docker e não nos recursos do computador host.

Contêineres do Informação de Documentos

Contêiner	Mínimo	Recomendadas
Read	8 núcleos, 10 GB de memória	8 núcleos, 24 GB de memória
Layout	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória
Business Card	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória
General Document	8 núcleos, 12 GB de memória	8 núcleos, 24 GB de memória
ID Document	8 núcleos, 8 GB de memória	8 núcleos, 24 GB de memória
Invoice	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória
Receipt	8 núcleos, 11 GB de memória	8 núcleos, 24 GB de memória
Custom Template	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória

• Cada núcleo precisa ser de pelo menos 2,6 GHz (gigahertz) ou mais rápido.
• Memória e núcleo correspondem às configurações --cpus e --memory, que são usadas como parte do comando docker compose ou docker run.

Dica

Você pode usar o comando imagens do estivador para listar as imagens do contêiner transferidas por download. Por exemplo, o comando a seguir lista o ID, o repositório e a tag de cada imagem do contêiner transferida por download, formatada como uma tabela:

docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

IMAGE ID         REPOSITORY                TAG
<image-id>       <repository-path/name>    <tag-name>

Execute o contêiner com o comando docker-compose up

• Substitua os valores {ENDPOINT_URI} e {API_KEY} pelo URI do ponto de extremidade do recurso e pela chave da página de recursos do Azure.

  

• Verifique se o valor EULA está definido como accept.

• Os valores EULA, Billing, e ApiKey devem ser especificados; caso contrário, o contêiner não poderá iniciar.

Importante

As chaves são utilizadas para acessar o recurso de Informação de Documentos. Não compartilhe suas chaves. Armazene-as com segurança, por exemplo, usando o Azure Key Vault. Recomendamos a regeneração regular dessas chaves. Apenas uma chave é necessária para fazer uma chamada à API. Ao regenerar a primeira chave, você pode usar a segunda chave para obter acesso contínuo ao serviço.

Leitura

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Layout de Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores DE {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_recognizer_KEY} na sua instância de contêiner de Layout.

version: "3.9"
services:
  azure-form-recognizer-read:
    container_name: azure-form-recognizer-read
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/read-3.1
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
    ports:
      - "5000:5000"
    networks:
      - ocrvnet
networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Documento geral

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Documentos Gerais da Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores {FORM_recognizer_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} nas suas instâncias de contêiner de Documento Geral e Layout.

version: "3.9"
services:
  azure-cognitive-service-document:
    container_name: azure-cognitive-service-document
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/document-3.0
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}
        - AzureCognitiveServiceLayoutHost=http://azure-cognitive-service-layout:5000
    ports:
      - "5000:5050"
  azure-cognitive-service-layout:
     container_name: azure-cognitive-service-layout
     image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout-3.0
     environment:
         - EULA=accept
         - billing={FORM_RECOGNIZER_ENDPOINT_URI}
         - apiKey={FORM_RECOGNIZER_KEY}

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Dados os recursos na computador, o contêiner de Documento Geral pode levar algum tempo para inicializar.

Layout

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Layout de Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores DE {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_recognizer_KEY} na sua instância de contêiner de Layout.

version: "3.9"
services:
  azure-form-recognizer-layout:
    container_name: azure-form-recognizer-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout-3.1
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
    ports:
      - "5000:5000"
    networks:
      - ocrvnet
networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Fatura

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Fatura da Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores DE {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_recognizer_KEY} nas suas instâncias de contêiner de Fatura e Layout.

Você deve usar a imagem de Layout em GA 3.1 como um upstream para modelos de fatura em GA 3.0 e 3.1.

version: "3.9"
services:
  azure-cognitive-service-invoice:
    container_name: azure-cognitive-service-invoice
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/invoice-3.1
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}
        - AzureCognitiveServiceLayoutHost=http://azure-cognitive-service-layout:5000
    ports:
      - "5000:5050"
  azure-cognitive-service-layout:
    container_name: azure-cognitive-service-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout-3.1
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Receipt

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Documentos Gerais da Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores {FORM_recognizer_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} nas suas instâncias de contêiner de Recebimento e Leitura.

Você pode usar a imagem de Layout em GA 3.1 como um upstream em vez de imagem de leitura.

version: "3.9"
services:
  azure-cognitive-service-receipt:
    container_name: azure-cognitive-service-receipt
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/receipt-3.1
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}
        - AzureCognitiveServiceReadHost=http://azure-cognitive-service-read:5000
    ports:
          - "5000:5050"
    azure-cognitive-service-read:
      container_name: azure-cognitive-service-read
      image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/read-3.1
      environment:
          - EULA=accept
          - billing={FORM_RECOGNIZER_ENDPOINT_URI}
          - apiKey={FORM_RECOGNIZER_KEY}

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Documento de identificação

O código de exemplo a seguir é um exemplo independente docker compose para executar o contêiner de Documentos Gerais da Informação de Documentos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores DE {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_recognizer_KEY} nas suas Instâncias de contêiner de Identificação e Leitura.

Você pode usar a imagem de Layout em GA 3.1 como um upstream em vez de imagem de leitura.

version: "3.9"
services:
  azure-cognitive-service-id-document:
      container_name: azure-cognitive-service-id-document
      image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/id-document-3.1
      environment:
          - EULA=accept
          - billing={FORM_RECOGNIZER_ENDPOINT_URI}
          - apiKey={FORM_RECOGNIZER_KEY}
          - AzureCognitiveServiceReadHost=http://azure-cognitive-service-read:5000
      ports:
          - "5000:5050"
  azure-cognitive-service-read:
      container_name: azure-cognitive-service-read
      image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/read-3.1
      environment:
          - EULA=accept
          - billing={FORM_RECOGNIZER_ENDPOINT_URI}
          - apiKey={FORM_RECOGNIZER_KEY}

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Cartão de visita

version: "3.9"
services:
  azure-cognitive-service-invoice:
    container_name: azure-cognitive-service-businesscard
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/businesscard-3.0
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}
        - AzureCognitiveServiceLayoutHost=http://azure-cognitive-service-layout:5000
    ports:
      - "5000:5050"
  azure-cognitive-service-layout:
    container_name: azure-cognitive-service-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout-3.0
    environment:
        - EULA=accept
        - billing={FORM_RECOGNIZER_ENDPOINT_URI}
        - apiKey={FORM_RECOGNIZER_KEY}

Personalizado

Além dos pré-requisitos, é necessário fazer o seguinte para processar um documento personalizado:

Criar uma pasta e armazenar os seguintes arquivos

• .env
• nginx.conf
• docker-compose.yml

Criar uma pasta e armazenar os dados de entrada

• Nomeie esta pasta como arquivos.
• Fazemos referência ao caminho do arquivo para essa pasta como {FILE_MOUNT_PATH}.
• Copie o caminho do arquivo em um local conveniente, você precisa adicioná-lo ao seu arquivo .env. Como exemplo, se a pasta for chamada de arquivos, localizada na mesma pasta do arquivo docker-compose, a entrada do arquivo .env será FILE_MOUNT_PATH="./files"

Crie uma pasta para armazenar os logs gravados pelo serviço de Informação de Documentos no seu computador local

• Nomeie esta pasta como saída.
• Referenciamos o caminho do arquivo para esta pasta como {OUTPUT_MOUNT_PATH}.
• Copie o caminho do arquivo em um local conveniente, você precisa adicioná-lo ao seu arquivo .env. Como exemplo, se a pasta for chamada de saída, localizada na mesma pasta do arquivo docker-compose, a entrada do arquivo .env será OUTPUT_MOUNT_PATH="./output"

Criar uma pasta para armazenar o processamento interno compartilhado entre contêineres

• Nomeie esta pasta como compartilhada.
• Referenciamos o caminho do arquivo para esta pasta como {SHARED_MOUNT_PATH}.
• Copie o caminho do arquivo em um local conveniente, você precisa adicioná-lo ao seu arquivo .env. Como exemplo, se a pasta for chamada de compartilhada, localizada na mesma pasta do arquivo docker-compose, a entrada do arquivo .env será SHARED_MOUNT_PATH="./shared"

Crie uma pasta para o Estúdio armazenar as informações relacionadas ao projeto

• Nomeie esta pasta db.
• Fazemos referência ao caminho do arquivo para esta pasta como {DB_MOUNT_PATH}.
• Copie o caminho do arquivo em um local conveniente, você precisa adicioná-lo ao seu arquivo .env. Como exemplo, se a pasta for chamada de banco de dados, localizada na mesma pasta do arquivo docker-compose, a entrada do arquivo .env será DB_MOUNT_PATH="./db"

Criar um arquivo de ambiente

1. Nomeie este arquivo .env.

2. Declare estas variáveis de ambiente:

SHARED_MOUNT_PATH="./shared"
OUTPUT_MOUNT_PATH="./output"
FILE_MOUNT_PATH="./files"
DB_MOUNT_PATH="./db"
FORM_RECOGNIZER_ENDPOINT_URI="YourFormRecognizerEndpoint"
FORM_RECOGNIZER_KEY="YourFormRecognizerKey"
NGINX_CONF_FILE="./nginx.conf"

Criar um arquivo nginx

1. Nomeie esse arquivo nginx.conf.

2. Use a seguinte configuração:

worker_processes 1;

events { worker_connections 1024; }

http {

    sendfile on;
    client_max_body_size 90M;
    upstream docker-custom {
        server azure-cognitive-service-custom-template:5000;
    }

    upstream docker-layout {
        server  azure-cognitive-service-layout:5000;
    }

    server {
        listen 5000;

        location = / {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;
            proxy_pass http://docker-custom/;
        }

        location /status {
            proxy_pass http://docker-custom/status;
        }

        location /test {
            return 200 $scheme://$host:$server_port;
        }

        location /ready {
            proxy_pass http://docker-custom/ready;
        }

        location /swagger {
            proxy_pass http://docker-custom/swagger;
        }

        location /formrecognizer/documentModels/prebuilt-layout {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;

            add_header 'Access-Control-Allow-Origin' '*' always;
            add_header 'Access-Control-Allow-Headers' 'cache-control,content-type,ocp-apim-subscription-key,x-ms-useragent' always;
            add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS' always;
            add_header 'Access-Control-Expose-Headers' '*' always;

            if ($request_method = 'OPTIONS') {
                return 200;
            }

            proxy_pass http://docker-layout/formrecognizer/documentModels/prebuilt-layout;
        }

        location /formrecognizer/documentModels {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;

            add_header 'Access-Control-Allow-Origin' '*' always;
            add_header 'Access-Control-Allow-Headers' 'cache-control,content-type,ocp-apim-subscription-key,x-ms-useragent' always;
            add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS, DELETE' always;
            add_header 'Access-Control-Expose-Headers' '*' always;

            if ($request_method = 'OPTIONS') {
                return 200;
            }

            proxy_pass http://docker-custom/formrecognizer/documentModels;
        }

        location /formrecognizer/operations {
            add_header 'Access-Control-Allow-Origin' '*' always;
            add_header 'Access-Control-Allow-Headers' 'cache-control,content-type,ocp-apim-subscription-key,x-ms-useragent' always;
            add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS, PUT, DELETE, PATCH' always;
            add_header 'Access-Control-Expose-Headers' '*' always;

            if ($request_method = OPTIONS ) {
                return 200;
            }

            proxy_pass http://docker-custom/formrecognizer/operations;
        }
    }
}

Criar um arquivo docker compose

1. Nomeie esse arquivo como docker-compose.yml

2. O código de exemplo a seguir é um exemplo do docker compose autônomo para executar os contêineres de modelos de Layout de Informação de Documentos, Estúdio e Personalizado juntos. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up.

version: '3.3'
services:
  nginx:
    image: nginx:alpine
    container_name: reverseproxy
    volumes:
      - ${NGINX_CONF_FILE}:/etc/nginx/nginx.conf
    ports:
      - "5000:5000"
  layout:
    container_name: azure-cognitive-service-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout-3.0:latest
    environment:
      eula: accept
      apikey: ${FORM_RECOGNIZER_KEY}
      billing: ${FORM_RECOGNIZER_ENDPOINT_URI}
      Logging:Console:LogLevel:Default: Information
      SharedRootFolder: /shared
      Mounts:Shared: /shared
      Mounts:Output: /logs
    volumes:
      - type: bind
        source: ${SHARED_MOUNT_PATH}
        target: /shared
      - type: bind
        source: ${OUTPUT_MOUNT_PATH}
        target: /logs
    expose:
      - "5000"

  custom-template:
    container_name: azure-cognitive-service-custom-template
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/custom-template-3.0:latest
    restart: always
    depends_on:
      - layout
    environment:
      AzureCognitiveServiceLayoutHost: http://azure-cognitive-service-layout:5000
      eula: accept
      apikey: ${FORM_RECOGNIZER_KEY}
      billing: ${FORM_RECOGNIZER_ENDPOINT_URI}
      Logging:Console:LogLevel:Default: Information
      SharedRootFolder: /shared
      Mounts:Shared: /shared
      Mounts:Output: /logs
    volumes:
      - type: bind
        source: ${SHARED_MOUNT_PATH}
        target: /shared
      - type: bind
        source: ${OUTPUT_MOUNT_PATH}
        target: /logs
    expose:
      - "5000"

  studio:
    container_name: form-recognizer-studio
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/studio:3.0
    environment:
      ONPREM_LOCALFILE_BASEPATH: /onprem_folder
      STORAGE_DATABASE_CONNECTION_STRING: /onprem_db/Application.db
    volumes:
      - type: bind
        source: ${FILE_MOUNT_PATH} # path to your local folder
        target: /onprem_folder
      - type: bind
        source: ${DB_MOUNT_PATH} # path to your local folder
        target: /onprem_db
    ports:
      - "5001:5001"
    user: "1000:1000" # echo $(id -u):$(id -g)

O contêiner de modelo personalizado e o contêiner de layout podem usar as filas de Armazenamento do Microsoft Azure ou em filas de memória. As variáveis de ambiente Storage:ObjectStore:AzureBlob:ConnectionString e queue:azure:connectionstring só precisam ser definidas se você estiver usando as filas de Armazenamento do Microsoft Azure. Ao executar localmente, exclua essas variáveis.

Certifique-se que o serviço esteja em execução

Para garantir que o serviço está em execução. Execute esses comandos em um shell do Ubuntu.

$cd <folder containing the docker-compose file>

$source .env

$docker-compose up

Os contêineres de modelo personalizados exigem algumas configurações diferentes e dão suporte a outras configurações opcionais.

Configuração	Obrigatória	Descrição
EULA	Sim	Exemplo de aceitação de licença: Eula=accept
Cobrança	Sim	URI do ponto de extremidade de cobrança do recurso FR
ApiKey	Sim	A chave de ponto de extremidade do recurso FR
Queue:Azure:ConnectionString	Não	Cadeia de conexão do Fila do Azure
Storage:ObjectStore:AzureBlob:ConnectionString	Não	Cadeia de conexão do Blob do Azure
HealthCheck:MemoryUpperboundInMB	Não	Limite de memória para relatar problemas de integridade à atividade. Padrão: o mesmo que a memória recomendada
StorageTimeToLiveInMinutes	Não	Duração da TTL para remover todos os arquivos intermediários e finais. Padrão: dois dias, o TTL pode ser definido entre cinco minutos e sete dias
Task:MaxRunningTimeSpanInMinutes	Não	Tempo de execução máximo para tratar a solicitação como tempo limite. Padrão: 60 minutos
HTTP_PROXY_BYPASS_URLS	Não	Exemplo de especificação de URLs para ignorar o proxy: HTTP_PROXY_BYPASS_URLS = abc.com, xyz.com
AzureCognitiveServiceReadHost (apenas contêineres Receipt, IdDocument)	Sim	Exemplo de especificação de URI do contêiner de leitura: AzureCognitiveServiceReadHost=http://onprem-frread:5000
AzureCognitiveServiceLayoutHost (apenas contêineres de documentos e faturas)	Sim	Exemplo de especificação de URI do contêiner: AzureCognitiveServiceLayoutHost=http://onprem-frlayout:5000

Utilize o Estúdio de Informação de Documentos para treinar um modelo

• Reúna um conjunto de pelo menos cinco formas do mesmo tipo. Você usará esses dados para treinar o modelo e testar um formulário. Você usar um conjunto de dados de exemplo (baixar e extrair sample_data.zip).

• Uma vez confirmado que os contêineres estão em execução, abra um navegador e navegue até o ponto de extremidade em que os contêineres estão implantados. Se esta implantação for seu computador local, o ponto de extremidade será [http://localhost:5001](http://localhost:5001).

• Selecione o bloco do modelo de extração personalizada.

• Selecione a opção Create project.

• Forneça um nome de projeto e, opcionalmente, uma descrição

• Na etapa "configurar seu recurso", forneça o ponto de extremidade para seu modelo de modelo personalizado. Se tiver implantado os contêineres no seu computador local, utilize esta URL [http://localhost:5000](http://localhost:5000).

• Forneça uma subpasta na qual os dados de treinamento estejam localizados na pasta de arquivos.

• Finalmente, crie o projeto

Neste momento, você deve ter um projeto criado, pronto para rotulagem. Faça upload de seus dados de treinamento e comece a rotular. Se você é novo na rotulagem, consulte criar e treinar um modelo personalizado.

Usando a API para treinar

Se você planeja chamar as APIs diretamente para treinar um modelo, a API de treinamento de modelo do modelo personalizado requer um arquivo ZIP codificado em base64 que é o conteúdo do seu projeto de rotulagem. Você pode omitir os arquivos PDF ou de imagem e enviar somente os arquivos JSON.

Depois de ter seu conjunto de dados rotulado e arquivos * .ocr.json, * .labels.json e fields.json adicionados a um ZIP, use os comandos do PowerShell para gerar a cadeia de caracteres codificada em base64.

$bytes = [System.IO.File]::ReadAllBytes("<your_zip_file>.zip")
$b64String = [System.Convert]::ToBase64String($bytes, [System.Base64FormattingOptions]::None)

Use a API do modelo de compilação para postar a solicitação.

POST http://localhost:5000/formrecognizer/documentModels:build?api-version=2023-07-31

{
    "modelId": "mymodel",
    "description": "test model",
    "buildMode": "template",

    "base64Source": "<Your base64 encoded string>",
    "tags": {
       "additionalProp1": "string",
       "additionalProp2": "string",
       "additionalProp3": "string"
     }
}

Confirme se o servidor está em execução

Há várias maneiras de validar se um contêiner está em execução:

• O contêiner fornece uma home page em \ como uma validação visual de que o contêiner está em execução.

• Você pode abrir seu navegador da Web favorito e navegar até o endereço IP externo e a porta exposta do contêiner em questão. Use as URLs de solicitação listadas para validar se o contêiner está em execução. As URLs de solicitação de exemplo listadas são http://localhost:5000, mas o seu contêiner específico pode variar. Lembre-se de que você está navegando para o endereço IP externo e porta exposta do contêiner.

  URL de Solicitação	Finalidade
  http://localhost:5000/	O contêiner fornece uma home page.
  http://localhost:5000/ready	Solicitado com GET, essa solicitação fornece uma verificação de que o contêiner está pronto para aceitar uma consulta em relação ao modelo. Essa solicitação pode ser usada para testes de preparação e de execução do Kubernetes.
  http://localhost:5000/status	Solicitado com GET, essa solicitação verifica se a chave API usada para iniciar o contêiner é válida sem causar uma consulta de terminal. Essa solicitação pode ser usada para testes de preparação e de execução do Kubernetes.
  http://localhost:5000/swagger	O contêiner fornece um conjunto completo de documentação para os pontos de extremidade e um recurso Experimentar. Com esse recurso, é possível inserir suas configurações em um formulário HTML baseado na Web e realizar a consulta sem precisar escrever nenhum código. Depois que a consulta é retornada, um exemplo de comando CURL é fornecido para demonstrar o formato do corpo e dos cabeçalhos HTTP exigidos.

Parar os contêineres

Para parar o contêiner, use o seguinte comando:

docker-compose down

Cobrança

Os contêineres de Informação de Documentos enviam informações de cobrança para o Azure utilizando um recurso de Informação de Documentos na sua conta do Azure.

Consultas para o contêiner são cobradas pelo tipo de preço do recurso do Azure usado para a API Key. A cobrança é calculada por cada instância de contêiner usada para processar seus documentos e imagens.

Se você receber este erro: O contêiner não está em um estado válido. Falha na validação da assinatura com o status "OutOfQuota". A chave de API excedeu a cota. Isso indica que seus contêineres não estão se comunicando corretamente com o ponto de extremidade de cobrança.

Conectar-se ao Azure

O contêiner precisa dos valores de argumento de cobrança para ser executado. Esses valores permitem que o contêiner se conecte ao ponto de extremidade de cobrança. O contêiner relata o uso a cada 10 a 15 minutos. Se o contêiner não se conectar ao Azure dentro da janela de tempo permitida, ele continuará sendo executado, mas não atenderá a consultas até que o ponto de extremidade de cobrança seja restaurado. Serão realizadas 10 tentativas de conexão no mesmo intervalo de tempo de 10 a 15 minutos. Se não for possível conectar-se ao ponto de extremidade de cobrança dentro das 10 tentativas, o contêiner interromperá as solicitações de serviço. Veja as Perguntas frequentes sobre a IA do Azure para obter um exemplo das informações enviadas à Microsoft para cobrança.

Argumentos de cobrança

O comando docker-compose up iniciará o contêiner quando todas as três opções a seguir forem fornecidas com valores válidos:

Opção	Descrição
ApiKey	A chave do recurso dos serviços de IA do Azure utilizada para rastrear as informações de cobrança. O valor dessa opção deve ser definido como uma chave para o recurso provisionado especificado em Billing.
Billing	O ponto de extremidade do recurso dos serviços de IA do Azure usado para rastrear informações de cobrança. O valor dessa opção deve ser definido como o URI do ponto de extremidade de um recurso do Azure provisionado.
Eula	Indica que você aceitou a licença do contêiner. O valor dessa opção deve ser definido como aceitar.

Para obter mais informações sobre essas opções, consulte Configurar contêineres.

Resumo

É isso! Neste artigo, você aprendeu conceitos e fluxos de trabalho para baixar, instalar e executar os contêineres do Informação de Documentos. Em resumo:

• O Informação de Documentos fornece sete contêineres Linux para o Docker.
• As imagens de contêiner são baixadas do mcr.
• Imagens de contêiner são executadas no Docker.
• A informações de cobrança devem ser especificadas quando você instanciar um contêiner.

Importante

Os contêineres dos serviços de IA do Azure não estão licenciados para serem executados sem uma conexão ao Azure para medição. Os clientes precisam ativar os contêineres para comunicar informações de cobrança com o serviço de medição em todos os momentos. Os contêineres de IA do Azure não enviam dados do cliente (por exemplo, a imagem ou o texto que está sendo analisado) para a Microsoft.

Próximas etapas

• Configurações do contêiner do Informação de Documentos

• Receita da instância de contêiner do Azure