Usar a Análise de Texto para o contêiner de integridade
Os contêineres permitem que você hospede a API do Análise de Texto de integridade em sua própria infraestrutura. Se você tiver requisitos de segurança ou governança de dados que não podem ser atendidos com a chamada de Análise de Texto para integridade remota, os contêineres poderão ser uma boa opção.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
Pré-requisitos
Você deve cumprir os seguintes pré-requisitos antes de usar a Análise de Texto para o contêiner de integridade. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
- Docker instalado em um computador host. 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.
- É preciso ter conhecimentos básicos sobre os conceitos do Docker.
- Um Recurso de linguagem com o tipo de preço Gratuito (F0) ou Standard (S).
Reunir os parâmetros necessários
São necessários três parâmetros principais para todos os contêineres de IA do Azure. O Termos de Licença para Software Microsoft precisam estar presentes com um valor igual a aceito. Um URI do ponto de extremidade e uma chave de API também são necessários.
URI do ponto de extremidade
O valor do {ENDPOINT_URI} está disponível na página Visão geral do portal do Azure do recurso dos serviços de IA do Azure correspondente. Acesse a página Visão geral, posicione o cursor sobre o ponto de extremidade, e um ícone Copiar para a área de transferência será exibido. Copie e use o ponto de extremidade quando necessário.
Teclas
O valor da {API_KEY} é usado para iniciar o contêiner e está disponível na página Chaves do portal do Azure do recurso dos serviços de IA do Azure correspondente. Acesse a página Chaves e selecione o ícone Copiar para a área de transferência .
Importante
Essas chaves de assinatura são usadas para acessar a API dos serviços de IA do Azure. Não compartilhe suas chaves. Armazene-as com segurança. Por exemplo, use o Azure Key Vault. Também recomendamos que você regenere essas chaves regularmente. Apenas uma chave é necessária para fazer uma chamada à API. Ao regenerar a primeira chave, você pode usar a segunda chave para acesso contínuo ao serviço.
Recomendações e 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.
A tabela a seguir descreve as especificações mínimas e recomendadas para a Análise de Texto para o contêiner de integridade. Cada núcleo de CPU precisa ser de pelo menos 2,6 GHz (gigahertz) ou mais rápido. A lista também mostra as transações permitidas por seção (TPS).
| Especificações mínimas do host | Especificações recomendadas do host | TPS mínimo | TPS máximo | |
|---|---|---|---|---|
| 1 documento/solicitação | 4 núcleos, 12 GB de memória | 6 núcleos, 12 GB de memória | 15 | 30 |
| 10 documentos/solicitação | 6 núcleos, 16 GB de memória | 8 núcleos, 20 GB de memória | 15 | 30 |
Os núcleos de CPU e a memória correspondem às configurações --cpus e --memory, que são usadas como parte do comando docker run.
Obter a imagem de contêiner com docker pull
A imagem de contêiner da Análise de Texto para saúde pode ser encontrada na agregação do registro de contêiner mcr.microsoft.com. Ela reside no repositório azure-cognitive-services/textanalytics/ e é chamada healthcare. O nome da imagem de contêiner totalmente qualificado é mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare
Para usar a versão mais recente do contêiner, você pode usar a tag latest. Encontre também uma lista completa de marcas no MCR.
Use o comando docker pull para baixar essa imagem de contêiner do registro de contêiner público da Microsoft. Você pode encontrar as marcas apresentadas no Registro de Contêiner da Microsoft
docker pull mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:<tag-name>
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>
Executar o contêiner com docker run
Quando o contêiner está no computador host, use o comando docker run para executar os contêineres. O contêiner continua a ser executado até que você o pare.
Importante
- os comandos do Docker nas seções a seguir usam a barra invertida,
\, como um caractere de continuação de linha. Substitua ou remova essa barra com base nos requisitos do sistema operacional de seu computador host. - As opções
Eula,BillingeApiKeydevem ser especificadas para executar o contêiner; caso contrário, o contêiner não será iniciado. Para mais informações, consulte Faturamento.- A confirmação IA responsável (RAI) também deve estar presente com um valor de
accept.
- A confirmação IA responsável (RAI) também deve estar presente com um valor de
- Os contêineres de análise de sentimento e de detecção de idioma usam a v3 da API e estão em disponibilidade geral. O contêiner de extração de frases-chave usa a v2 da API e está em versão prévia.
Há várias maneiras possíveis de instalar e executar a Análise de Texto para o contêiner de integridade.
- Use o portal do Azure para criar um recurso de Linguagem e use o Docker para obter seu contêiner.
- Use uma VM do Azure com o Docker para executar o contêiner.
- Use os scripts do PowerShell e do CLI do Azure a seguir para automatizar a implantação de recursos e a configuração do contêiner.
Quando você usa a Análise de Texto para contêiner de integridade, os dados contidos em suas solicitações e respostas de API não são visíveis para a Microsoft e não são usados para treinamento do modelo aplicado aos seus dados.
Executar o contêiner localmente
Para executar o contêiner em seu próprio ambiente depois de baixar a imagem de contêiner, execute o comando docker run. Substitua os espaços reservados abaixo por seus próprios valores:
| Espaço reservado | Valor | Formato ou exemplo |
|---|---|---|
| {API_KEY} | A chave para o recurso de idioma. É possível encontrá-lo na página de Chave e ponto de extremidade do recurso, no portal do Azure. | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
| {ENDPOINT_URI} | O ponto de extremidade para acessar a API. É possível encontrá-lo na página de Chave e ponto de extremidade do recurso, no portal do Azure. | https://<your-custom-subdomain>.cognitiveservices.azure.com |
docker run --rm -it -p 5000:5000 --cpus 6 --memory 12g \
mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:<tag-name> \
Eula=accept \
rai_terms=accept \
Billing={ENDPOINT_URI} \
ApiKey={API_KEY}
Esse comando:
- Executa uma Análise de Texto para o contêiner de integridade da imagem de contêiner
- Aloca 6 núcleos de CPU e 12 GB (gigabytes) de memória
- Expõe a porta TCP 5000 e aloca um pseudo-TTY para o contêiner
- Aceita os termos EULA (contrato de licença de usuário final) e RAI (AI responsável)
- Remove automaticamente o contêiner depois que ele sai. A imagem de contêiner ainda fica disponível no computador host.
Interface do usuário de demonstração para visualizar a saída
O contêiner fornece APIs de ponto de extremidade de previsão de consulta baseadas em REST. Também fornecemos uma ferramenta de visualização no contêiner que é acessível acrescentando /demo ao ponto de extremidade do contêiner. Por exemplo:
http://<serverURL>:5000/demo
Use o exemplo de solicitação de cURL abaixo para enviar uma consulta ao contêiner que você implantou, substituindo a serverURL variável pelo valor apropriado.
curl -X POST 'http://<serverURL>:5000/text/analytics/v3.1/entities/health' --header 'Content-Type: application/json' --header 'accept: application/json' --data-binary @example.json
Instalar o contêiner usando o Aplicativo Azure Web para Contêineres
O Azure Aplicativo Web para Contêineres é um recurso do Azure dedicado à execução de contêineres na nuvem. Ele traz recursos prontos para uso, como dimensionamento automático, suporte a contêineres do docker e ao docker compose, suporte a HTTPS e muito mais.
Observação
Usando o aplicativo Web do Azure, você obterá automaticamente um domínio na forma de <appservice_name>.azurewebsites.net
Execute este script do PowerShell usando o CLI do Azure para criar um Aplicativo Web para Contêineres, usando sua assinatura e a imagem de contêiner sobre HTTPS. Aguarde até que o script seja concluído (aproximadamente 25 a 30 minutos) antes de enviar a primeira solicitação.
$subscription_name = "" # THe name of the subscription you want you resource to be created on.
$resource_group_name = "" # The name of the resource group you want the AppServicePlan
# and AppSerivce to be attached to.
$resources_location = "" # This is the location you wish the AppServicePlan to be deployed to.
# You can use the "az account list-locations -o table" command to
# get the list of available locations and location code names.
$appservice_plan_name = "" # This is the AppServicePlan name you wish to have.
$appservice_name = "" # This is the AppService resource name you wish to have.
$TEXT_ANALYTICS_RESOURCE_API_KEY = "" # This should be taken from the Language resource.
$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT = "" # This should be taken from the Language resource.
$DOCKER_IMAGE_NAME = "mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:latest"
az login
az account set -s $subscription_name
az appservice plan create -n $appservice_plan_name -g $resource_group_name --is-linux -l $resources_location --sku P3V2
az webapp create -g $resource_group_name -p $appservice_plan_name -n $appservice_name -i $DOCKER_IMAGE_NAME
az webapp config appsettings set -g $resource_group_name -n $appservice_name --settings Eula=accept rai_terms=accept Billing=$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT ApiKey=$TEXT_ANALYTICS_RESOURCE_API_KEY
# Once deployment complete, the resource should be available at: https://<appservice_name>.azurewebsites.net
Instalar o contêiner usando a instância de contêiner do Azure
Você também pode usar um Azure Container Instance (ACI) para facilitar a implantação. O ACI é um recurso que permite executar contêineres do Docker sob demanda em um ambiente gerenciado e sem servidor do Azure.
Consulte Como usar as Instâncias de Contêiner do Azure para obter etapas sobre como implantar um recurso ACI usando o portal do Azure. Você também pode usar o script do PowerShell abaixo usando CLI do Azure, que criará um ACI em sua assinatura usando a imagem de contêiner. Aguarde até que o script seja concluído (aproximadamente 25 a 30 minutos) antes de enviar a primeira solicitação. Devido ao limite do número máximo de CPUs por recurso ACI, não selecione esta opção se você espera enviar mais de 5 documentos grandes (aproximadamente 5000 caracteres cada) por solicitação. Consulte o artigo de suporte regional do ACI para obter informações de disponibilidade.
Observação
As Instâncias de Contêiner do Azure não incluem suporte a HTTPS para os domínios internos. Caso precisar de HTTPS, será necessário configurá-lo manualmente, incluindo a criação de um certificado e o registro de um domínio. É possível encontrar instruções para fazer isso com o NGINX abaixo.
$subscription_name = "" # The name of the subscription you want you resource to be created on.
$resource_group_name = "" # The name of the resource group you want the AppServicePlan
# and AppService to be attached to.
$resources_location = "" # This is the location you wish the web app to be deployed to.
# You can use the "az account list-locations -o table" command to
# Get the list of available locations and location code names.
$azure_container_instance_name = "" # This is the AzureContainerInstance name you wish to have.
$TEXT_ANALYTICS_RESOURCE_API_KEY = "" # This should be taken from the Language resource.
$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT = "" # This should be taken from the Language resource.
$DNS_LABEL = "" # This is the DNS label name you wish your ACI will have
$DOCKER_IMAGE_NAME = "mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:latest"
az login
az account set -s $subscription_name
az container create --resource-group $resource_group_name --name $azure_container_instance_name --image $DOCKER_IMAGE_NAME --cpu 4 --memory 12 --port 5000 --dns-name-label $DNS_LABEL --environment-variables Eula=accept rai_terms=accept Billing=$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT ApiKey=$TEXT_ANALYTICS_RESOURCE_API_KEY
# Once deployment complete, the resource should be available at: http://<unique_dns_label>.<resource_group_region>.azurecontainer.io:5000
Conectividade segura do ACI
Por padrão, não há nenhuma segurança fornecida ao usar ACI com a API do contêiner. Isso ocorre porque normalmente os contêineres serão executados como parte de um pod que é protegido do exterior por uma ponte de rede. No entanto, é possível modificar um contêiner com um componente frontal, mantendo o ponto de extremidade do contêiner privado. Os exemplos a seguir usam o Nginx como um gateway de entrada para dar suporte a autenticação para o HTTPS/SSL e certificado de cliente.
Observação
NGINX é um servidor e proxy HTTP de software open-source e de alto desempenho. Um contêiner NGINX pode ser usado para encerrar uma conexão TLS para um único contêiner. Soluções de terminação TLS baseadas em NGINX de entrada mais complexas também são possíveis.
Configurar o NGINX como um gateway de entrada
O NGINX usa arquivos de configuração para habilitar recursos em tempo de execução. Para habilitar o encerramento de TLS para outro serviço, você deve especificar um certificado SSL para encerrar a conexão TLS e proxy_pass para especificar um endereço para o serviço. Um exemplo é fornecido abaixo.
Observação
ssl_certificate espera que um caminho seja especificado no sistema de arquivos local do contêiner NGINX. O endereço especificado para proxy_pass deve estar disponível na rede do contêiner NGINX.
O contêiner NGINX carregará todos os arquivos no _.conf_que está montado no /etc/nginx/conf.d/caminho de configuração de HTTP.
server {
listen 80;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
# replace with .crt and .key paths
ssl_certificate /cert/Local.crt;
ssl_certificate_key /cert/Local.key;
location / {
proxy_pass http://cognitive-service:5000;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
}
Exemplo de arquivo Docker compose
O exemplo abaixo mostra como um arquivo docker compose pode ser criado para implantar o NGINX e contêineres de integridade:
version: "3.7"
services:
cognitive-service:
image: {IMAGE_ID}
ports:
- 5000:5000
environment:
- eula=accept
- billing={ENDPOINT_URI}
- apikey={API_KEY}
volumes:
# replace with path to logs folder
- <path-to-logs-folder>:/output
nginx:
image: nginx
ports:
- 443:443
volumes:
# replace with paths for certs and conf folders
- <path-to-certs-folder>:/cert
- <path-to-conf-folder>:/etc/nginx/conf.d/
Para iniciar esse arquivo Docker compose, execute o seguinte comando em um console no nível raiz do arquivo:
docker-compose up
Para obter mais informações, consulte a documentação do NGINX na Terminação do SSL do NGINX.
Executar vários contêineres no mesmo host
Se você pretende executar vários contêineres com portas expostas, execute cada um deles com uma porta exposta diferente. Por exemplo, execute o primeiro contêiner na porta 5000 e o segundo contêiner na porta 5001.
É possível ter esse contêiner e um contêiner dos serviços de IA do Azure em execução no HOST juntos. Também é possível ter vários contêineres do mesmo contêiner dos serviços de IA do Azure em execução.
Consultar o ponto de extremidade de previsão do contêiner
O contêiner fornece APIs de ponto de extremidade de previsão de consulta baseadas em REST.
Use o host, http://localhost:5000, para as APIs do contêiner.
Validar se um contêiner está em execução
Há várias maneiras de validar se um contêiner está em execução. Localize o endereço IP externo e a porta exposta do contêiner em questão e abra seu navegador da Web favorito. Use as várias URLs de solicitação a seguir para validar se o contêiner está em execução. Os exemplos de URLs de solicitação listados aqui são http://localhost:5000, mas seu contêiner específico poderá variar. Dependa do endereço IP externo do seu contêiner e da porta exposta.
| URL de Solicitação | Finalidade |
|---|---|
http://localhost:5000/ |
O contêiner fornece uma home page. |
http://localhost:5000/ready |
Solicitada com GET, essa URL fornece uma verificação que indica que o contêiner está pronto para aceitar uma consulta no modelo. Essa solicitação pode ser usada para testes de preparação e de execução do Kubernetes. |
http://localhost:5000/status |
Também solicitada com GET, essa URL verifica se a chave API usada para iniciar o contêiner é válida sem causar uma consulta de ponto de extremidade. 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. Após a consulta ser retornada, um exemplo de comando CURL será fornecido para demonstrar o formato do corpo e dos cabeçalhos HTTP exigidos. |
Estruturar a solicitação de API para o contêiner
Você pode usar a extensão do cliente REST do Visual Studio Code ou o exemplo de solicitação cURL abaixo para enviar uma consulta ao contêiner que você implantou, substituindo a variável serverURL pelo valor apropriado. Observe que a versão da API na URL do contêiner é diferente da API hospedada.
Observação
O recurso FHIR (Fast Healthcare Interoperability Resources) está disponível no contêiner mais recente e é exposto por meio da nova API REST de linguagem.
curl -i -X POST 'http://<serverURL>:5000/language/analyze-text/jobs?api-version=2022-04-01-preview' --header 'Content-Type: application/json' --header --data-binary @example.json
O código JSON abaixo é um exemplo de um arquivo JSON anexado ao corpo de POST da solicitação de Linguagem:
example.json
{
"analysisInput": {
"documents": [
{
"text": "The doctor prescried 200mg Ibuprofen.",
"language": "en",
"id": "1"
}
]
},
"tasks": [
{
"taskName": "analyze 1",
"kind": "Healthcare",
"parameters": {
"fhirVersion": "4.0.1"
}
}
]
}
Corpo da resposta do contêiner
O código JSON abaixo é um exemplo do corpo da resposta da Linguagem à chamada síncrona em contêiner:
{
"jobId": "{JOB-ID}",
"lastUpdateDateTime": "2022-04-18T15:50:16Z",
"createdDateTime": "2022-04-18T15:50:14Z",
"expirationDateTime": "2022-04-19T15:50:14Z",
"status": "succeeded",
"errors": [],
"tasks": {
"completed": 1,
"failed": 0,
"inProgress": 0,
"total": 1,
"items": [
{
"kind": "HealthcareLROResults",
"taskName": "analyze 1",
"lastUpdateDateTime": "2022-04-18T15:50:16.7046515Z",
"status": "succeeded",
"results": {
"documents": [
{
"id": "1",
"entities": [
{
"offset": 4,
"length": 6,
"text": "doctor",
"category": "HealthcareProfession",
"confidenceScore": 0.76
},
{
"offset": 21,
"length": 5,
"text": "200mg",
"category": "Dosage",
"confidenceScore": 0.99
},
{
"offset": 27,
"length": 9,
"text": "Ibuprofen",
"category": "MedicationName",
"confidenceScore": 1.0,
"name": "ibuprofen",
"links": [
{ "dataSource": "UMLS", "id": "C0020740" },
{ "dataSource": "AOD", "id": "0000019879" },
{ "dataSource": "ATC", "id": "M01AE01" },
{ "dataSource": "CCPSS", "id": "0046165" },
{ "dataSource": "CHV", "id": "0000006519" },
{ "dataSource": "CSP", "id": "2270-2077" },
{ "dataSource": "DRUGBANK", "id": "DB01050" },
{ "dataSource": "GS", "id": "1611" },
{ "dataSource": "LCH_NW", "id": "sh97005926" },
{ "dataSource": "LNC", "id": "LP16165-0" },
{ "dataSource": "MEDCIN", "id": "40458" },
{ "dataSource": "MMSL", "id": "d00015" },
{ "dataSource": "MSH", "id": "D007052" },
{ "dataSource": "MTHSPL", "id": "WK2XYI10QM" },
{ "dataSource": "NCI", "id": "C561" },
{ "dataSource": "NCI_CTRP", "id": "C561" },
{ "dataSource": "NCI_DCP", "id": "00803" },
{ "dataSource": "NCI_DTP", "id": "NSC0256857" },
{ "dataSource": "NCI_FDA", "id": "WK2XYI10QM" },
{ "dataSource": "NCI_NCI-GLOSS", "id": "CDR0000613511" },
{ "dataSource": "NDDF", "id": "002377" },
{ "dataSource": "PDQ", "id": "CDR0000040475" },
{ "dataSource": "RCD", "id": "x02MO" },
{ "dataSource": "RXNORM", "id": "5640" },
{ "dataSource": "SNM", "id": "E-7772" },
{ "dataSource": "SNMI", "id": "C-603C0" },
{ "dataSource": "SNOMEDCT_US", "id": "387207008" },
{ "dataSource": "USP", "id": "m39860" },
{ "dataSource": "USPMG", "id": "MTHU000060" },
{ "dataSource": "VANDF", "id": "4017840" }
]
}
],
"relations": [
{
"relationType": "DosageOfMedication",
"entities": [
{
"ref": "#/results/documents/0/entities/1",
"role": "Dosage"
},
{
"ref": "#/results/documents/0/entities/2",
"role": "Medication"
}
]
}
],
"warnings": [],
"fhirBundle": {
"resourceType": "Bundle",
"id": "bae9d4e0-191e-48e6-9c24-c1ff6097c439",
"meta": {
"profile": [
"http://hl7.org/fhir/4.0.1/StructureDefinition/Bundle"
]
},
"identifier": {
"system": "urn:ietf:rfc:3986",
"value": "urn:uuid:bae9d4e0-191e-48e6-9c24-c1ff6097c439"
},
"type": "document",
"entry": [
{
"fullUrl": "Composition/9044c2cc-dcec-4b9d-b005-bfa8be978aa8",
"resource": {
"resourceType": "Composition",
"id": "9044c2cc-dcec-4b9d-b005-bfa8be978aa8",
"status": "final",
"type": {
"coding": [
{
"system": "http://loinc.org",
"code": "11526-1",
"display": "Pathology study"
}
],
"text": "Pathology study"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"encounter": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"date": "2022-04-18",
"author": [
{
"reference": "Practitioner/fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"type": "Practitioner",
"display": "Unknown"
}
],
"title": "Pathology study",
"section": [
{
"title": "General",
"code": {
"coding": [
{
"system": "",
"display": "Unrecognized Section"
}
],
"text": "General"
},
"text": {
"div": "<div>\r\n\t\t\t\t\t\t\t<h1>General</h1>\r\n\t\t\t\t\t\t\t<p>The doctor prescried 200mg Ibuprofen.</p>\r\n\t\t\t\t\t</div>"
},
"entry": [
{
"reference": "List/db388912-b5fb-4073-a74c-2751fd3374dd",
"type": "List",
"display": "General"
}
]
}
]
}
},
{
"fullUrl": "Practitioner/fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"resource": {
"resourceType": "Practitioner",
"id": "fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"extension": [
{
"extension": [
{ "url": "offset", "valueInteger": -1 },
{ "url": "length", "valueInteger": 7 }
],
"url": "http://hl7.org/fhir/StructureDefinition/derivation-reference"
}
],
"name": [{ "text": "Unknown", "family": "Unknown" }]
}
},
{
"fullUrl": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"resource": {
"resourceType": "Patient",
"id": "5c554347-4290-4b05-83ac-6637ff3bfb40",
"gender": "unknown"
}
},
{
"fullUrl": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"resource": {
"resourceType": "Encounter",
"id": "6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"meta": {
"profile": [
"http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter"
]
},
"status": "finished",
"class": {
"system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
"display": "unknown"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
}
}
},
{
"fullUrl": "MedicationStatement/24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"resource": {
"resourceType": "MedicationStatement",
"id": "24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"extension": [
{
"extension": [
{ "url": "offset", "valueInteger": 27 },
{ "url": "length", "valueInteger": 9 }
],
"url": "http://hl7.org/fhir/StructureDefinition/derivation-reference"
}
],
"status": "active",
"medicationCodeableConcept": {
"coding": [
{
"system": "http://www.nlm.nih.gov/research/umls",
"code": "C0020740",
"display": "Ibuprofen"
},
{
"system": "http://www.nlm.nih.gov/research/umls/aod",
"code": "0000019879"
},
{
"system": "http://www.whocc.no/atc",
"code": "M01AE01"
},
{
"system": "http://www.nlm.nih.gov/research/umls/ccpss",
"code": "0046165"
},
{
"system": "http://www.nlm.nih.gov/research/umls/chv",
"code": "0000006519"
},
{
"system": "http://www.nlm.nih.gov/research/umls/csp",
"code": "2270-2077"
},
{
"system": "http://www.nlm.nih.gov/research/umls/drugbank",
"code": "DB01050"
},
{
"system": "http://www.nlm.nih.gov/research/umls/gs",
"code": "1611"
},
{
"system": "http://www.nlm.nih.gov/research/umls/lch_nw",
"code": "sh97005926"
},
{ "system": "http://loinc.org", "code": "LP16165-0" },
{
"system": "http://www.nlm.nih.gov/research/umls/medcin",
"code": "40458"
},
{
"system": "http://www.nlm.nih.gov/research/umls/mmsl",
"code": "d00015"
},
{
"system": "http://www.nlm.nih.gov/research/umls/msh",
"code": "D007052"
},
{
"system": "http://www.nlm.nih.gov/research/umls/mthspl",
"code": "WK2XYI10QM"
},
{
"system": "http://ncimeta.nci.nih.gov",
"code": "C561"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_ctrp",
"code": "C561"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_dcp",
"code": "00803"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_dtp",
"code": "NSC0256857"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_fda",
"code": "WK2XYI10QM"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_nci-gloss",
"code": "CDR0000613511"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nddf",
"code": "002377"
},
{
"system": "http://www.nlm.nih.gov/research/umls/pdq",
"code": "CDR0000040475"
},
{
"system": "http://www.nlm.nih.gov/research/umls/rcd",
"code": "x02MO"
},
{
"system": "http://www.nlm.nih.gov/research/umls/rxnorm",
"code": "5640"
},
{
"system": "http://snomed.info/sct",
"code": "E-7772"
},
{
"system": "http://snomed.info/sct/900000000000207008",
"code": "C-603C0"
},
{
"system": "http://snomed.info/sct/731000124108",
"code": "387207008"
},
{
"system": "http://www.nlm.nih.gov/research/umls/usp",
"code": "m39860"
},
{
"system": "http://www.nlm.nih.gov/research/umls/uspmg",
"code": "MTHU000060"
},
{
"system": "http://hl7.org/fhir/ndfrt",
"code": "4017840"
}
],
"text": "Ibuprofen"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"context": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"dosage": [
{
"text": "200mg",
"doseAndRate": [{ "doseQuantity": { "value": 200 } }]
}
]
}
},
{
"fullUrl": "List/db388912-b5fb-4073-a74c-2751fd3374dd",
"resource": {
"resourceType": "List",
"id": "db388912-b5fb-4073-a74c-2751fd3374dd",
"status": "current",
"mode": "snapshot",
"title": "General",
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"encounter": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"entry": [
{
"item": {
"reference": "MedicationStatement/24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"type": "MedicationStatement",
"display": "Ibuprofen"
}
}
]
}
}
]
}
}
],
"errors": [],
"modelVersion": "2022-03-01"
}
}
]
}
}
Executar o contêiner com suporte à biblioteca de cliente
Começando com a versão do contêiner 3.0.017010001-onprem-amd64 (ou se você usar o contêiner latest), você pode executar o Análise de Texto para verificar a integridade do contêiner usando a biblioteca de cliente. Para fazê-lo, adicione este parâmetro ao comando docker run:
enablelro=true
Posteriormente, quando você autenticar objeto cliente, use o ponto de extremidade em que seu contêiner está em execução:
http://localhost:5000
Por exemplo, se você estiver usando C#, usaria o seguinte código:
var client = new TextAnalyticsClient("http://localhost:5000", "your-text-analytics-key");
Parar o contêiner
Para desligar o contêiner, no ambiente de linha de comando em que o contêiner estiver em execução, selecione Ctrl+C.
Solução de problemas
Se você executar o contêiner com uma montagem de saída e o registro em log habilitado, o contêiner gerará arquivos de log que são úteis para solucionar problemas que ocorrem durante a inicialização ou execução do contêiner.
Dica
Para obter mais informações e diretrizes para a solução de problemas, confira Perguntas frequentes sobre os contêineres dos serviços de IA do Azure.
Cobrança
A Análise de Texto para o contêiner de integridade enviam informações de cobrança para o Azure, usando um recurso de Linguagem na conta do Azure.
Consultas ao contêiner são cobradas pelo tipo de preço do recurso do Azure usado para o parâmetro ApiKey.
Os contêineres dos serviços de IA do Azure não estão licenciados para execução sem estarem conectados ao ponto de extremidade de medição ou cobrança. Você precisa permitir que os contêineres comuniquem as informações de cobrança com o ponto de extremidade de cobrança em todos os momentos. Os contêineres dos serviços de IA do Azure não enviam dados do cliente, como imagem ou texto que está sendo analisado, para a Microsoft.
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 contêineres dos serviços de IA do Azure para obter um exemplo das informações enviadas à Microsoft para cobrança.
Argumentos de cobrança
O comando docker run 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 de API do recurso dos 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 de API para o recurso provisionado especificado em Billing. |
Billing |
O ponto de extremidade do recurso de serviços de IA do Azure que é utilizado para rastrear as 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. |
Resumo
Neste artigo, você aprendeu conceitos e fluxo de trabalho para baixar, instalar e executar a Análise de Texto para o contêiner de integridade. Em resumo:
- O Análise de Texto para integridade fornece um contêiner do Linux para o Docker
- Imagens de contêiner são baixadas do Registro de Contêiner da Microsoft (MCR).
- Imagens de contêiner são executadas no Docker.
- Você pode usar a API REST ou o SDK para chamar as operações em Análise de Texto para o contêiner de integridade especificando o URI do host do contêiner.
- Você deve especificar informações de faturamento ao 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 dos serviços de IA do Azure não enviam dados do cliente (por exemplo, o texto que está sendo analisado) para a Microsoft.
Próximas etapas
- Confira Configurar contêineres para definições de configuração.