Instalar e executar contentores

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

O Azure AI Document Intelligence é um serviço de IA do Azure que lhe permite criar software de processamento automatizado de dados utilizando tecnologia de aprendizagem automática. O Document Intelligence permite-lhe identificar e extrair texto, pares chave/valor, marcas de seleção, dados de tabelas e muito mais dos seus documentos. Os resultados são entregues como dados estruturados que .. /inclui 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ê pode aprender como baixar, instalar e executar contêineres de Document Intelligence. Os contêineres permitem que você execute o serviço de Inteligência de Documentos em seu próprio ambiente. Os contentores são ótimos para requisitos específicos de governação de dados e segurança.

• Os modelos de Leitura, Layout, Documento de ID, Recibo e Fatura são suportados pelos contêineres do Document Intelligence v3.1.

• Os modelos Leitura, Layout, Documento Geral, Cartão de Visita e Personalizado são suportados pelos contêineres do Document Intelligence v3.0.

Suporte da versão

O suporte para contêineres está atualmente disponível com a versão v3.0: 2022-08-31 (GA) Document Intelligence para todos os modelos e v3.1 2023-07-31 (GA) para os modelos de Leitura, Layout, Documento de ID, Recibo e Fatura:

• API REST v3.0: 2022-08-31 (GA)
• API REST v3.1: 2023-07-31 (GA)
• Segmentação de bibliotecas de clientes REST API v3.0: 2022-08-31 (GA)
• Segmentação de bibliotecas de clientes REST API v3.1: 2023-07-31 (GA)

Pré-requisitos

Para começar, você precisa de uma conta ativa do Azure. Se não tiver uma, poderá criar uma conta gratuita.

Você também precisa do seguinte para usar contêineres de Document Intelligence:

Necessário	Propósito
Familiaridade com o Docker	Você deve ter uma compreensão básica dos conceitos do Docker, como registros, repositórios, contêineres e imagens de contêiner, bem como conhecimento de terminologia básica docker e comandos.
Mecanismo do Docker instalado	Você precisa do Docker Engine instalado em um computador host. O Docker oferece pacotes que configuram o ambiente do Docker no macOS, no Windows e no Linux. Para um manual de noções básicas do Docker e do contentor, veja a descrição geral do Docker. O Docker deve ser configurado para permitir que os contêineres se conectem e enviem dados de cobrança para o Azure. No Windows, o Docker também deve ser configurado para suportar contêineres Linux .
Recurso de Inteligência Documental	Um recurso de inteligência documental do Azure AI de serviço único ou um recurso multisserviço no portal do 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 Document Intelligence Keys and Endpoint do portal do Azure: {FORM_RECOGNIZER_KEY}: uma das duas chaves de recurso disponíveis. {FORM_RECOGNIZER_ENDPOINT_URI}: o ponto de extremidade do recurso usado para rastrear informações de cobrança.

Opcional	Propósito
CLI do Azure (interface de linha de comando)	A CLI do Azure permite que você use um conjunto de comandos online para criar e gerenciar recursos do Azure. Ele está disponível para instalação em ambientes Windows, macOS e Linux e pode ser executado 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. Pode ser um computador em suas instalações ou um serviço de hospedagem do Docker no Azure, como:

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

Nota

Observe que o contêiner do Studio não pode ser implantado e executado no Serviço Kubernetes do Azure. O contêiner Studio só é suportado para ser executado na máquina local.

Requisitos e recomendações de contêineres

Contentores de suporte necessários

A tabela a seguir lista um ou mais contêineres de suporte para cada contêiner de Document Intelligence baixado. Para obter mais informações, consulte a seção Faturamento .

Contêiner de recursos	Contentores de suporte
Ler	Não obrigatório
Esquema	Não obrigatório
Cartão de visita	Ler
Documento Geral	Esquema
Fatura	Esquema
Receção	Leitura ou layout
Documento de identificação	Ler
Modelo personalizado	Esquema

Núcleos de CPU e memória recomendados

Nota

Os valores mínimos e recomendados são baseados nos limites do Docker e não nos recursos da máquina host.

Contentores de Inteligência Documental

Contentor	Mínimo	Recomendado
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 deve ter pelo menos 2,6 gigahertz (GHz) ou mais rápido.
• O núcleo e a memória correspondem às --cpus configurações e --memory , que são usadas como parte do docker compose comando or docker run .

Gorjeta

Você pode usar o comando docker images para listar as imagens de contêiner baixadas. Por exemplo, o comando a seguir lista o ID, o repositório e a tag de cada imagem de contêiner baixada, 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.

  

• Certifique-se de que o EULA valor está definido para aceitar.

• Os EULAvalores , Billing, e devem ApiKey ser especificados, caso contrário, o contêiner não pode ser iniciado.

Importante

As chaves são usadas para acessar seu recurso de Document Intelligence. Não partilhe as chaves. Armazene-os de forma segura, por exemplo, usando o Azure Key Vault. Recomendamos também que gere novas chaves regularmente. Só é necessária uma chave para fazer uma chamada à API. Ao gerar novamente a primeira chave, pode utilizar a segunda chave para o acesso continuado ao serviço.

Ler

O exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Intelligence Layout. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com o docker-compose up comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância do contêiner 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 exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Geral do Document Intelligence. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para suas instâncias de contêiner 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 máquina, o contêiner Documento Geral pode levar algum tempo para ser iniciado.

Esquema

O exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Intelligence Layout. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância do contêiner 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 exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Intelligence Invoice. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para suas instâncias de contêiner Invoice e Layout.

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

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

Receção

O exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Geral do Document Intelligence. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para suas instâncias de contêiner de Recebimento e Leitura.

Você pode usar a imagem de layout do GA 3.1 como uma imagem upstream em vez de Ler.

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 exemplo de código a seguir é um exemplo autônomo docker compose para executar o contêiner Document Geral do Document Intelligence. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração. Insira os valores {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para suas instâncias de contêiner de ID e Leitura.

Você pode usar a imagem de layout do GA 3.1 como uma imagem upstream em vez de Ler.

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}

Personalizadas

Além dos pré-requisitos, você precisa fazer o seguinte para processar um documento personalizado:

Crie uma pasta e armazene os seguintes arquivos

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

Crie uma pasta e armazene seus dados de entrada

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

Crie uma pasta para armazenar os logs gravados pelo serviço de Inteligência de Documentos em sua máquina local

• Nomeie esta pasta como saída.
• Fazemos referência ao 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 . Por exemplo, se a pasta for chamada de saída, localizada na mesma pasta que o docker-compose arquivo, a entrada do arquivo .env será OUTPUT_MOUNT_PATH="./output"

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

• Nomeie esta pasta compartilhada.
• Fazemos referência ao 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 . Por exemplo, se a pasta for chamada compartilhada, localizada na mesma pasta que o docker-compose arquivo, a entrada do arquivo .env será SHARED_MOUNT_PATH="./share"

Criar uma pasta para o Studio armazenar informações relacionadas ao projeto

• Nomeie esta pasta como 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 . Por exemplo, se a pasta for chamada db, localizada na mesma pasta que o docker-compose arquivo, a entrada do arquivo .env será DB_MOUNT_PATH="./db"

Criar um ficheiro de ambiente

1. Nomeie este arquivo .env.

2. Declare as seguintes variáveis de ambiente:

SHARED_MOUNT_PATH="./share"
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 este arquivo nginx.conf.

2. Insira 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 de composição do docker

1. Nomeie este arquivo docker-compose.yml

2. O exemplo de código a seguir é um exemplo autônomo docker compose para executar contêineres de modelo Document Intelligence Layout, Studio e Custom juntos. Com docker composeo , você usa um arquivo YAML para configurar os serviços do seu aplicativo. Em seguida, com docker-compose up o comando, você cria e inicia todos os serviços da sua configuração.

version: '3.3'
services:
  nginx:
    image: nginx:alpine
    container_name: reverseproxy
    depends_on:
      - layout
      - custom-template  
    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.1: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.1: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 filas de Armazenamento do Azure ou em filas de memória. As Storage:ObjectStore:AzureBlob:ConnectionString variáveis e queue:azure:connectionstring de ambiente só precisam ser definidas se você estiver usando filas de Armazenamento do Azure. Ao executar localmente, exclua essas variáveis.

Verifique se o serviço está em execução

Para garantir que o serviço está instalado e funcionando. 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 suportam outras configurações opcionais.

Definição	Obrigatório	Descrição
EULA	Sim	Exemplo de aceitação de licença: Eula=accept
Faturação	Sim	URI do ponto de extremidade de faturamento do recurso FR
ApiKey	Sim	A chave do ponto final do recurso FR
Fila:Azure:ConnectionString	Não	Cadeia de conexão da Fila do Azure
Storage:ObjectStore:AzureBlob:ConnectionString	Não	Cadeia de conexão de Blob do Azure
HealthCheck:MemóriaUpperboundInMB	Não	Limiar de memória para relatar insalubridade à vivacidade. Padrão: o mesmo que a memória recomendada
StorageTimeToLiveInMinutes	Não	TTL duração para remover todos os ficheiros intermédios e finais. Padrão: Dois dias, TTL pode definir entre cinco minutos a sete dias
Tarefa:MaxRunningTimeSpanInMinutes	Não	Tempo máximo de execução para tratar a solicitação como tempo limite. Padrão: 60 minutos
HTTP_PROXY_BYPASS_URLS	Não	Especificar URLs para ignorar proxy Exemplo: HTTP_PROXY_BYPASS_URLS = abc.com, xyz.com
AzureCognitiveServiceReadHost (recibo, somente contêineres IdDocument)	Sim	Especificar uri de contêiner de leitura Exemplo:AzureCognitiveServiceReadHost=http://onprem-frread:5000
AzureCognitiveServiceLayoutHost (somente documento, contêineres de fatura)	Sim	Especificar uri de contêiner de layout Exemplo:AzureCognitiveServiceLayoutHost=http://onprem-frlayout:5000

Usar o Document Intelligence Studio para treinar um modelo

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

• Depois de confirmar que os contêineres estão em execução, abra um navegador e navegue até o ponto de extremidade onde você implantou os contêineres. Se essa implantação for sua máquina local, o ponto de extremidade será [http://localhost:5001](http://localhost:5001).

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

• Selecione a Create project opção.

• 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 você implantou os contêineres em sua máquina local, use esta URL [http://localhost:5000](http://localhost:5000).

• Forneça uma subpasta para onde seus dados de treinamento estão localizados dentro da pasta de arquivos.

• Finalmente, crie o projeto

Agora você deve ter um projeto criado, pronto para rotulagem. Carregue seus dados de treinamento e comece a rotular. Se você é novo em 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 de 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 apenas os arquivos JSON.

Depois de ter seu conjunto de dados rotulado e *.ocr.json, *.labels.json e fields.json arquivos adicionados a um zip, use os comandos do PowerShell para gerar a cadeia de caracteres codificada 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"
     }
}

Validar se o serviço está em execução

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

• O contêiner fornece uma página inicial como \ uma validação visual de que o contêiner está sendo executado.

• Você pode abrir seu navegador 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 que o contêiner está em execução. Os URLs de solicitação de exemplo listados são http://localhost:5000, mas seu contêiner específico pode variar. Lembre-se de que você está navegando para o endereço IP externo e a porta exposta do contêiner.

  URL do Pedido	Propósito
  http:// localhost:5000/	O contentor fornece uma home page.
  http:// localhost:5000/ready	Solicitada com GET, essa solicitação fornece uma verificação de que o contêiner está pronto para aceitar uma consulta no modelo. Essa solicitação pode ser usada para sondas de vivacidade e prontidão do Kubernetes.
  http:// localhost:5000/status	Solicitada com GET, essa solicitação verifica se a chave de api usada para iniciar o contêiner é válida sem causar uma consulta de ponto de extremidade. Essa solicitação pode ser usada para sondas de vivacidade e prontidão do Kubernetes.
  http:// localhost:5000/swagger	O contentor fornece um conjunto completo de documentação para os pontos finais e uma funcionalidade Experimentar. Com esse recurso, você pode inserir suas configurações em um formulário HTML baseado na Web e fazer a consulta sem ter que escrever nenhum código. Depois que a consulta retorna, um comando CURL de exemplo é fornecido para demonstrar os cabeçalhos HTTP necessários e o formato do corpo.

Pare os contentores

Para parar os contêineres, use o seguinte comando:

docker-compose down

Faturação

Os contêineres de Document Intelligence enviam informações de cobrança para o Azure usando um recurso de Document Intelligence em sua conta do Azure.

As consultas ao contêiner são cobradas na camada de preço do recurso do Azure usado para a API Key. O faturamento é calculado para cada instância de contêiner usada para processar seus documentos e imagens.

Se você receber o seguinte erro: O contêiner não está em um estado válido. A validação da assinatura falhou com o status 'OutOfQuota' A chave da API está fora da cota. É um indicador de que seus contêineres não estão se comunicando com o ponto de extremidade de faturamento.

Ligar ao Azure

O contêiner precisa dos valores do argumento de faturamento para ser executado. Esses valores permitem que o contêiner se conecte ao ponto de extremidade de faturamento. 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, o contêiner continuará a ser executado, mas não atenderá consultas até que o ponto de extremidade de cobrança seja restaurado. A conexão é tentada 10 vezes no mesmo intervalo de tempo de 10 a 15 minutos. Se ele não puder se conectar ao ponto de extremidade de faturamento dentro das 10 tentativas, o contêiner interromperá o atendimento de solicitações. Consulte as Perguntas frequentes sobre o contêiner do Azure AI para obter um exemplo das informações enviadas à Microsoft para cobrança.

Argumentos de faturação

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

Opção	Description
ApiKey	A chave do recurso de serviços de IA do Azure usada para rastrear 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 de 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 provisionado do Azure.
Eula	Indica que você aceitou a licença para o contêiner. O valor desta opção deve ser definido como accept.

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

Resumo

Está feito! Neste artigo, você aprendeu conceitos e fluxos de trabalho para baixar, instalar e executar contêineres de Document Intelligence. Em resumo:

• A Document Intelligence fornece sete contêineres Linux para o Docker.
• As imagens de contêiner são baixadas do mcr.
• As imagens de contêiner são executadas no Docker.
• As informações de faturamento devem ser especificadas quando você instanciar um contêiner.

Importante

Os contêineres de IA do Azure não são licenciados para serem executados sem estarem conectados ao Azure para medição. Os clientes precisam permitir que os contêineres comuniquem informações de faturamento 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óximos passos

• Definições de configuração do contêiner do Document Intelligence

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