Usar a Análise de Texto para contêineres de integridade
Os contêineres permitem que você hospede a API de Análise de Texto para integridade em sua própria infraestrutura. Se você tiver requisitos de segurança ou governança de dados que não podem ser atendidos chamando a Análise de Texto para integridade remotamente, os contêineres podem ser uma boa opção.
Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.
Pré-requisitos
Você deve atender aos seguintes pré-requisitos antes de usar a Análise de Texto para contêineres de integridade. Se não tiver uma subscrição 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 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.
- Você deve ter uma compreensão básica dos conceitos do Docker.
- Um recurso de idioma com o nível de preço gratuito (F0) ou padrão (S).
Reúna os parâmetros necessários
Três parâmetros principais para todos os contêineres de IA do Azure são necessários. Os Termos de Licença para Software Microsoft devem estar presentes com um valor de aceitação. Um URI do ponto de extremidade e uma chave de API também são necessários.
URI do ponto de extremidade
O {ENDPOINT_URI} valor está disponível na página Visão geral do portal do Azure do recurso de serviços de IA do Azure correspondente. Vá para a página Visão geral , passe o mouse sobre o ponto de extremidade e um ícone Copiar para área de transferência será exibido. Copie e use o ponto de extremidade onde necessário.
Chaves
O {API_KEY} valor é usado para iniciar o contêiner e está disponível na página Chaves do portal do Azure do recurso de serviços de IA do Azure correspondente. Vá para a página Teclas e selecione o ícone Copiar para área de transferência.
Importante
Essas chaves de assinatura são usadas para acessar sua API de serviços de IA do Azure. Não partilhe as suas chaves. Armazene-os de forma segura. Por exemplo, use o Azure Key Vault. Também recomendamos que regenere essas chaves regularmente. Só é necessária uma chave para fazer uma chamada à API. Ao regenerar a primeira chave, você pode usar a segunda chave para acesso contínuo ao serviço.
Requisitos e recomendações 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.
A tabela a seguir descreve as especificações mínimas e recomendadas para o Text Analytics para contêineres de integridade. Cada núcleo da CPU deve ter pelo menos 2,6 gigahertz (GHz) ou mais rápido. As transações permitidas por segundo (TPS) também estão listadas.
| Especificações mínimas do host | Especificações de host recomendadas | TPS mínimo | TPS máximo | |
|---|---|---|---|---|
| 1 documento/pedido | 4 núcleos, 12GB de memória | 6 núcleos, 12GB de memória | 15 | 30 |
| 10 documentos/pedido | 6 núcleos, 16GB de memória | 8 núcleos, 20GB de memória | 15 | 30 |
O núcleo da CPU e a memória correspondem às --cpus configurações e --memory , que são usadas como parte do docker run comando.
Obtenha a imagem do contêiner com docker pull
A imagem do contêiner do Text Analytics for health pode ser encontrada no sindicato do registro do mcr.microsoft.com contêiner. Ele reside dentro do azure-cognitive-services/textanalytics/ repositório e é chamado healthcarede . O nome da imagem de contêiner totalmente qualificada é mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare
Para usar a versão mais recente do contêiner, você pode usar a latest tag . Você também pode encontrar uma lista completa de tags no MCR.
Use o docker pull comando para baixar essa imagem de contêiner do registro de contêiner público da Microsoft. Você pode encontrar as tags em destaque no Microsoft Container Registry
docker pull mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:<tag-name>
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 docker run
Quando o contêiner estiver no computador host, use o comando docker run para executar os contêineres. O contentor continuará a funcionar até ser parado.
Importante
- Os comandos docker nas seções a seguir usam a barra invertida,
\, como um caractere de continuação de linha. Substitua ou remova isso com base nos requisitos do sistema operacional do host. - As
Eulaopções ,Billinge devemApiKeyser especificadas para executar o contêiner, caso contrário, o contêiner não será iniciado. Para obter mais informações, consulte Faturamento.- O reconhecimento responsável da IA (RAI) também deve estar presente com um valor de
accept.
- O reconhecimento responsável da IA (RAI) também deve estar presente com um valor de
- Os contêineres de análise de sentimento e deteção de idioma usam a v3 da API e estão geralmente disponíveis. O contêiner de extração de frase-chave usa v2 da API e está em visualização.
Há várias maneiras de instalar e executar o contêiner Análise de Texto para integridade.
- Use o portal do Azure para criar um recurso de idioma e use o Docker para obter seu contêiner.
- Use uma VM do Azure com o Docker para executar o contêiner.
- Use os seguintes scripts do PowerShell e da CLI do Azure para automatizar a implantação de recursos e a configuração de contêineres.
Quando você usa o contêiner Análise de Texto para 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 treinar o modelo aplicado aos seus dados.
Executar o contentor localmente
Para executar o contêiner em seu próprio ambiente depois de baixar a imagem do contêiner, execute o seguinte docker run comando. Substitua os espaços reservados abaixo pelos seus próprios valores:
| Marcador de Posição | Value | Formato ou exemplo |
|---|---|---|
| {API_KEY} | A chave para o seu recurso linguístico. Você pode encontrá-lo na página Chave e ponto de extremidade do seu recurso, no portal do Azure. | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
| {ENDPOINT_URI} | O ponto de extremidade para acessar a API. Você pode encontrá-lo na página Chave e ponto de extremidade do seu 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}
Este comando:
- Executa o contêiner Análise de Texto para integridade a partir da imagem do contêiner
- Aloca 6 núcleos de CPU e 12 gigabytes (GB) de memória
- Expõe a porta TCP 5000 e aloca um pseudo-TTY para o contêiner
- Aceita os termos do contrato de licença de usuário final (EULA) e da IA responsável (RAI)
- Remove automaticamente o recipiente depois que ele sai. A imagem do contêiner ainda está disponível no computador host.
Interface de usuário de demonstração para visualizar a saída
O contentor fornece APIs de ponto final de predição de consulta com base em REST. Também fornecemos uma ferramenta de visualização no contêiner que é acessível anexando /demo ao ponto de extremidade do contêiner. Por exemplo:
http://<serverURL>:5000/demo
Use o exemplo de solicitação 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 Web do Azure para Contêineres
O Azure Web App for Containers é um recurso do Azure dedicado à execução de contêineres na nuvem. Ele traz recursos prontos para uso, como dimensionamento automático, suporte para contêineres docker e composição de docker, suporte a HTTPS e muito mais.
Nota
Usando o Azure Web App, você obterá automaticamente um domínio na forma de <appservice_name>.azurewebsites.net
Execute este script do PowerShell usando a CLI do Azure para criar um Aplicativo Web para Contêineres, usando sua assinatura e a imagem do contêiner por HTTPS. Aguarde a conclusão do script (aproximadamente 25-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 uma Instância de Contêiner do Azure (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 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 a CLI do Azure, que criará uma ACI em sua assinatura usando a imagem do contêiner. Aguarde a conclusão do script (aproximadamente 25-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 da ACI para obter informações sobre disponibilidade.
Nota
As Instâncias de Contêiner do Azure não incluem suporte HTTPS para os domínios internos. Se você precisar de HTTPS, precisará configurá-lo manualmente, incluindo a criação de um certificado e o registro de um domínio. Você pode encontrar instruções para fazer isso com 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 ACI segura
Por padrão, não há segurança fornecida ao usar ACI com API de contêiner. Isso ocorre porque normalmente os contêineres serão executados como parte de um pod que é protegido do lado de fora por uma ponte de rede. No entanto, você pode modificar um contêiner com um componente frontal, mantendo o ponto de extremidade do contêiner privado. Os exemplos a seguir usam NGINX como um gateway de entrada para oferecer suporte a HTTPS/SSL e autenticação de certificado de cliente.
Nota
NGINX é um servidor HTTP de código aberto e de alto desempenho e proxy. 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 ingresso NGINX 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 a terminação TLS para outro serviço, você deve especificar um certificado SSL para encerrar a conexão TLS e proxy_pass especificar um endereço para o serviço. Um exemplo é fornecido abaixo.
Nota
ssl_certificate espera que um caminho seja especificado dentro do 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 montados _.conf_ no /etc/nginx/conf.d/ caminho de configuração 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 de composição do Docker
O exemplo abaixo mostra como um arquivo de composição docker pode ser criado para implantar 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 de composição do Docker, execute o seguinte comando a partir de um console no nível raiz do arquivo:
docker-compose up
Para obter mais informações, consulte a documentação do NGINX sobre NGINX SSL Termination.
Executar vários contêineres no mesmo host
Se você pretende executar vários contêineres com portas expostas, certifique-se de executar cada contêiner com uma porta exposta diferente. Por exemplo, execute o primeiro contêiner na porta 5000 e o segundo contêiner na porta 5001.
Você pode ter esse contêiner e um contêiner de serviços de IA do Azure diferente em execução no HOST juntos. Você também pode ter vários contêineres do mesmo contêiner de serviços de IA do Azure em execução.
Consultar o ponto final de predição do contentor
O contentor fornece APIs de ponto final de predição de consulta com base em REST.
Utilize o anfitrião, http://localhost:5000, para APIs de contentor.
Validar se um contêiner está em execução
Há várias maneiras de validar se o 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 que o contêiner está em execução. Os URLs de solicitação de exemplo listados aqui são http://localhost:5000, mas seu contêiner específico pode variar. Certifique-se de confiar no endereço IP externo e na 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 URL 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 |
Também solicitada com GET, essa URL 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 e o formato de corpo necessários. |
Estruturar a solicitação de API para o contêiner
Você pode usar a extensão Visual Studio Code REST Client ou a solicitação cURL de exemplo abaixo para enviar uma consulta ao contêiner implantado, substituindo a serverURL variável pelo valor apropriado. Observe que a versão da API na URL do contêiner é diferente da API hospedada.
Nota
O recurso Fast Healthcare Interoperability Resources (FHIR) está disponível no contêiner mais recente e é exposto por meio da nova linguagem REST API.
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 JSON a seguir é um exemplo de um arquivo JSON anexado ao corpo POST da solicitação de idioma:
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 de resposta do recipiente
O JSON a seguir é um exemplo do corpo de resposta de idioma da 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 3.0.017010001-onprem-amd64 do contêiner (ou se você usar o latest contêiner), você pode executar o contêiner Análise de Texto para integridade usando a biblioteca do cliente. Para fazer isso, adicione o seguinte parâmetro ao docker run comando:
enablelro=true
Depois, ao autenticar o objeto cliente, use o ponto de extremidade em que seu contêiner está sendo executado:
http://localhost:5000
Por exemplo, se você estiver usando C#, você usaria o seguinte código:
var client = new TextAnalyticsClient("http://localhost:5000", "your-text-analytics-key");
Parar o contentor
Para desligar o contêiner, no ambiente de linha de comando em que o contêiner está sendo executado, selecione Ctrl+C.
Resolução de Problemas
Se você executar o contêiner com uma montagem de saída e registro em log habilitados, o contêiner gerará arquivos de log que serão úteis para solucionar problemas que acontecem ao iniciar ou executar o contêiner.
Gorjeta
Para obter mais informações e orientações sobre solução de problemas, consulte Perguntas frequentes (FAQ) sobre contêineres de IA do Azure.
Faturação
A Análise de Texto para contêineres de integridade envia informações de cobrança para o Azure, usando um recurso de idioma em sua conta do Azure.
As consultas ao contêiner são cobradas na camada de preço do recurso do Azure usado para o ApiKey parâmetro.
Os contêineres de serviços de IA do Azure não são licenciados para serem executados sem estarem conectados ao ponto de extremidade de medição ou cobrança. Você deve habilitar os contêineres para comunicar informações de faturamento com o ponto de extremidade de faturamento em todos os momentos. Os contêineres de serviços de IA do Azure não enviam dados do cliente, como a imagem ou o texto que está sendo analisado, para a Microsoft.
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 de serviços de IA do Azure para obter um exemplo das informações enviadas à Microsoft para cobrança.
Argumentos de faturação
O docker run comando iniciará o contêiner quando todas as três opções a seguir forem fornecidas com valores válidos:
| Opção | Description |
|---|---|
ApiKey |
A chave de API do recurso de serviços de IA do Azure que é 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 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. |
Resumo
Neste artigo, você aprendeu conceitos e fluxo de trabalho para baixar, instalar e executar a Análise de Texto para contêineres de integridade. Em resumo:
- A Análise de Texto para integridade fornece um contêiner Linux para o Docker
- As imagens de contêiner são baixadas do Microsoft Container Registry (MCR).
- As imagens de contêiner são executadas no Docker.
- Você pode usar a API REST ou o SDK para chamar operações na Análise de Texto para contêineres 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 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, texto que está sendo analisado) para a Microsoft.
Próximos passos
- Consulte Configurar contêineres para obter definições de configuração.