Computação em Nuvem é um paradigma de tecnologia da informação que permite o acesso onipresente a pools compartilhados de recursos de sistema configuráveis e serviços de nível superior que podem ser provisionados rapidamente com esforço mínimo de gerenciamento, muitas vezes pela Internet.
Visão Geral
Esta versão se concentra em aprimorar a confiabilidade, expandir a segurança e aprimorar a experiência de suporte em diversos Serviços em Nuvem da InterSystems. Com esta versão, todas as principais ofertas — incluindo FHIR Server, InterSystems Data Fabric Studio (IDS), IDS com Supply Chain e IRIS Managed Services — agora oferecem suporte ao Advanced Security, proporcionando uma postura de segurança unificada e aprimorada.
Novos Recursos e Melhoria
Olá, pessoal! Tendo me integrado recentemente à InterSystems, percebi que, apesar de ter uma Edição Comunitária totalmente gratuita e incrível, não é muito claro como obtê-la. Decidi escrever um guia destacando todas as diferentes maneiras de acessar a Edição Comunitária do InterSystems IRIS:
Trabalhar com uma instância em contêiner da Community Edition é a abordagem recomendada para quem está começando a desenvolver no InterSystems IRIS e, na minha opinião, é a mais simples. A Community Edition do InterSystems IRIS pode ser encontrada no DockerHub; se você tiver uma conta InterSystems SSO, também poderá encontrá-la no Registro de Contêineres da InterSystems.
Em ambos os casos, você vai querer extrair a imagem desejada usando o Docker CLI:
docker pull intersystems/iris-community:latest-em
// or
docker pull containers.intersystems.com/intersystems/iris-community:latest-emEm seguida, você precisará iniciar o contêiner: para interagir com o IRIS de fora do contêiner (por exemplo, para usar o portal de gerenciamento), você precisará publicar algumas portas. O comando a seguir executará o contêiner IRIS Community Edition com as portas do superservidor e do servidor web publicadas; observe que você não pode executar nada que dependa das portas 1972 ou 52773!
docker run --name iris -d --publish 1972:1972 --publish 52773:52773 intersystems/iris-community:latest-emÀs vezes, clientes precisam de uma pequena instância IRIS para fazer algo na nuvem e desligá-la, ou precisam de centenas de contêineres (ou seja, um por usuário final ou um por interface) com pequenas cargas de trabalho. Este exercício surgiu para ver quão pequena uma instância IRIS poderia ser. Para este exercício, focamos em qual é a menor quantidade de memória que podemos configurar para uma instância IRIS. Você conhece todos os parâmetros que afetam a memória alocada pelo IRIS?
Não tenho certeza se muitos se conectam ao MS SQL para executar consultas, procedimentos armazenados, etc., mas nosso Sistema de Saúde possui muitos bancos de dados baseados em MS SQL que utilizamos no ambiente de Interoperabilidade por vários motivos.
Com a migração do ambiente local para a nuvem, enfrentamos algumas dificuldades com as conexões do SQL Gateway e como configurá-las para usar o Microsoft Entra para autenticação do Active Directory.
Baseado num ótimo exemplo e workshop construído por @Luis Angel Pérez Ramos (veja artigos relacionados e o Open Exchange app relacionado), que incluiu um container local InterSystems for Health (e setup desejado), essa amostra apresentada aqui, adaptada do workshop para usar o InterSystems Cloud FHIR Server, e suas definições relacionadas.
No último artigo, falamos sobre alguns fatores iniciais do Django. Aprendemos como começar um projeto, garantir que temos todos os requisitos e fazer um CRUD. No entanto, hoje vamos um pouco mais além.
 | Como incluir dados do IRIS no seu Data Warehouse do Google Big Query e em suas explorações de dados do Data Studio. Neste artigo, vamos usar o Google Cloud Dataflow para nos conectarmos com o InterSystems Cloud SQL Service e criar um job para persistir os resultados de uma consulta do IRIS no Big Query em um intervalo. Se você teve a sorte de ganhar acesso ao Cloud SQL no Global Summit 2022, conforme mencionado em "InterSystems IRIS: What's New, What's Next", o exemplo será muito fácil. No entanto, também é possível fazer isso com qualquer listener acessível publicamente ou por VPC que você provisionar. |
jdbc:IRIS://k8s-c5ce7068-a4244044-265532e16d-2be47d3d6962f6cc.elb.us-east-1.amazonaws.com:1972/USERSQLAdmin/Testing12!com.intersystems.jdbc.IRISDrivergcloud projects create iris-2-datastudio --set-as-default
gcloud services enable bigquery.googleapis.com gcloud services enable dataflow.googleapis.com gcloud services enable storage.googleapis.com
gsutil mb gs://iris-2-datastudio
wget https://github.com/intersystems-community/iris-driver-distribution/raw/main/intersystems-jdbc-3.3.0.jar gsutil cp intersystems-jdbc-3.3.0.jar gs://iris-2-datastudio
bq --location=us mk \ --dataset \ --description "sqlaas to big query" \ iris-2-datastudio:irisdata
Aqui, uma vantagem superpoderosa se torna meio incômoda para nós. O Big Query pode criar tabelas dinamicamente se você fornecer um esquema com sua carga útil. Isso é ótimo dentro de pipelines e soluções, mas, em nosso caso, precisamos estabelecer a tabela com antecedência. O processo é simples, já que você pode exportar um CSV do banco de dados do IRIS facilmente com algo como o DBeaver, depois invocar a caixa de diálogo "criar tabela" abaixo do conjunto de dados criado e usar o CSV para criar sua tabela. Verifique se "gerar esquema automaticamente" está marcado na parte inferior da caixa de diálogo.
Isso conclui a configuração do Google Cloud Platform, e deve estar tudo pronto para configurar e executar o job do Dataflow.
Job do Google Dataflow
Se você seguiu as etapas acima, deverá ter o seguinte no seu inventário para executar o job de ler os dados do InterSystems IRIS e ingeri-los no Google Big Query usando o Google Dataflow.
No Console do Google Cloud, acesse o Dataflow e selecione "Criar job a partir do modelo"
Essa é uma ilustração um tanto desnecessária/exaustiva sobre como preencher um formulário com os pré-requisitos gerados, mas indica a origem dos componentes...
... para completar, abra a seção inferior e forneça suas credenciais do IRIS.
Para quem achou essas capturas de tela ofensivas à própria inteligência, aqui está o caminho alternativo para deixar você dentro da sua zona de conforto na CLI para executar o job:
gcloud dataflow jobs run iris-2-bq-dataflow \ --gcs-location gs://dataflow-templates-us-central1/latest/Jdbc_to_BigQuery \ --region us-central1 --num-workers 2 \ --staging-location gs://iris-2-datastudio/tmp \ --parameters connectionURL=jdbc:IRIS://k8s-c5ce7068-a4244044-265532e16d-2be47d3d6962f6cc.elb.us-east-1.amazonaws.com:1972/USER,driverClassName=com.intersystems.jdbc.IRISDriver,query=SELECT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, SELF_REFERENCING_COLUMN_NAME, REFERENCE_GENERATION, USER_DEFINED_TYPE_CATALOG, USER_DEFINED_TYPE_SCHEMA, USER_DEFINED_TYPE_NAME, IS_INSERTABLE_INTO, IS_TYPED, CLASSNAME, DESCRIPTION, OWNER, IS_SHARDED FROM INFORMATION_SCHEMA.TABLES;,outputTable=iris-2-datastudio:irisdata.dataflowtable,driverJars=gs://iris-2-datastudio/intersystems-jdbc-3.3.0.jar,bigQueryLoadingTemporaryDirectory=gs://iris-2-datastudio/input,username=SQLAdmin,password=Testing12!
Após iniciar o job, aproveite a glória de uma execução de job bem-sucedida:
Resultados
Observando a consulta e os dados de origem no InterSystems Cloud SQL...
... e inspecionando os resultados no Big Query, parece que realmente temos os dados do InterSystems IRIS no Big Query.
Depois de ter os dados no Big Query, é simples incluir nossos dados do IRIS no Data Studio ao selecionar o Big Query como fonte de dados... o exemplo abaixo não é muito elegante, mas você pode ver rapidamente os dados do IRIS prontos para manipulação no seu projeto do Data Studio.
Olá Desenvolvedores,
Assista a este vídeo para saber como implantar seu servidor FHIR usando AWS, EKS e Kubernetes: vantagens e desvantagens da implantação na nuvem e fazer uma demonstração de implantação:
Talvez você não perceba isso, mas sua conta de login da InterSystems pode ser usada para acessar uma ampla variedade de serviços da InterSystems que ajudam você a aprender e usar o InterSystems IRIS e outras tecnologias da InterSystems de maneira mais eficaz. Continue lendo para saber mais sobre como descobrir novos conhecimentos técnicos e ferramentas usando sua conta de login da InterSystems. Além disso, após a leitura, participe da Enquete na parte inferior, para que possamos ver como este artigo foi útil para você!
.png)
Uma conta de login da InterSystems é usada para acessar diversos serviços online que atendem a parceiros e clientes atuais e em potencial. É um conjunto único de credenciais usadas em mais de 15 aplicativos voltados ao público externo. Alguns aplicativos (como a WRC ou o iService) exigem uma ativação específica para o acesso ser concedido pela conta. Provavelmente, há recursos disponíveis que ajudarão você, mas você não os conhece: leia sobre todas as opções e teste uma nova ferramenta para melhorar sua técnica!!
Você pode ver todos os serviços disponíveis para você com sua conta de login da InterSystems ao acessar esse catálogo de aplicativos da InterSystems, localizado em: https://Login.InterSystems.com. Isso só listará os aplicativos ou serviços a que você tem acesso no momento. Ele lembra seus aplicativos usados com mais frequência e os lista na parte superior para sua conveniência.
.png)
Não se esqueça de marcar a página como favorita para acessar facilmente todas essas ferramentas na caixa de ferramentas da sua conta de login da InterSystems!
Agora, é hora de entrar nos detalhes de cada aplicativo e ver como eles podem ajudar você como desenvolvedor que trabalha com as tecnologias da InterSystems! Continue lendo e tente encontrar um novo aplicativo que você possa usar pela primeira vez para melhorar sua eficiência e habilidades como desenvolvedor....
.png)
Getting Started - gettingstarted.intersystems.com .png)
Online Learning - learning.intersystems.com.png)
Documentação - docs.intersystems.com
.png)
Evaluation - evaluation.intersystems.com.png)
Developer Community - community.intersystems.com.png)
Ideias da InterSystems - ideas.intersystems.com.png)
Global Masters - globalmasters.intersystems.com.png)
Open Exchange - openexchange.intersystems.com .png)
WRC - wrc.intersystems.com.png)
iService - iservice.intersystems.com.png)
ICR - containers.intersystems.com.png)
Diretório de Parceiros - partner.intersystems.com .png)
CCR - ccr.intersystems.com .png)
Client Connection - client.intersystems.com .png)
Pedidos online - store.intersystems.comAqui estão mais alguns fatos úteis sobre as contas de login da InterSystems...
Os usuários podem criar sua própria conta ao clicar em "Create Account" em qualquer aplicativo da InterSystems voltado ao público, incluindo:
Como alternativa, o FRC (First Response Center) da InterSystems criará uma conta de login para clientes atendidos pela primeira vez que precisarem acessar a Central de Suporte (WRC) ou o iService (os clientes atendidos também podem criar contas para os colegas).
Antes de usar a conta, o usuário precisa aceitar os Termos e Condições, durante o processo de autoinscrição ou no primeiro login.
.png)
Alguns aplicativos permitem o login com o Google ou GitHub:
É a mesma conta de login da InterSystems, mas com a autenticação pelo Google ou GitHub.
Se você for até https://Login.InterSystems.com e fizer a autenticação, poderá acessar Opções > Profile e fazer alterações básicas na sua conta. O e-mail pode ser alterado em Options > Change Email.
Os problemas das contas de login da InterSystems devem ser encaminhados para Support@InterSystems.com. Inclua o seguinte:
Se você estiver executando o IRIS em uma configuração espelhada para alta disponibilidade (HA) no Azure, a questão de fornecer um [VIP espelho] (https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_set_config#GHA_mirror_set_virtualip) (IP virtual) se torna relevante. O IP virtual oferece uma maneira de sistemas downstream interagirem com o IRIS usando um endereço IP. Mesmo quando ocorre uma tolerância a falhas, os sistemas downstream podem se reconectar ao mesmo endereço IP e continuar trabalhando.
O principal problema, ao implantar no Azure, é que um VIP IRIS requer que o IRIS seja basicamente um administrador de rede, de acordo com a documentação.
Para obter HA, os membros espelho IRIS precisam ser implantados em diferentes zonas de disponibilidade de uma sub-rede (o que é possível no Azure, já que as sub-redes podem abranger várias zonas). Uma das soluções pode ser os balanceadores de carga, mas eles têm um custo extra e você precisa administrá-los.
Neste artigo, quero fornecer uma maneira de configurar um VIP espelho sem usar os balanceadores de carga sugeridos na maioria das outras arquiteturas de referência do Azure.
Temos uma sub-rede em execução em duas zonas de disponibilidade (simplifiquei aqui: claro, você provavelmente terá sub-redes públicas, árbitro em outra az, e assim por diante, mas esse é o mínimo absoluto necessário para demonstrar essa abordagem). O CIDR da sub-rede é "10.0.0.0/24", ou seja, alocou os IPs "10.0.0.1" a "10.0.0.255". Como o Azure reserva os primeiros quatro endereços e o último, podemos usar "10.0.0.4" a "10.0.0.254".
Vamos implementar VIPs públicos e privados ao mesmo tempo. Se quiser, você pode implementar apenas o VIP privado.
As máquinas virtuais (VM) no Azure têm interfaces de rede. Essas interfaces de rede têm configurações de IP. A configuração de IP é uma combinação de IPs públicos e/ou privados e é roteada automaticamente para a máquina virtual associada à interface de rede. Portanto, não é preciso atualizar as rotas. Faremos o seguinte: durante um evento de tolerância a falhas de espelho, vamos excluir a configuração de IP VIP da primária antiga e criar uma nova primária. Todas as operações envolvidas nisso levam de 5 a 20 segundos apenas para o VIP privado, de 5 segundos a um minuto para uma combinação de IP VIP público/privado.
cat << EOFVIP >> /etc/sysconfig/network-scripts/ifcfg-eth0:1
DEVICE=eth0:1
ONPARENT=on
IPADDR=10.0.0.254
PREFIX=32
EOFVIP
sudo chmod -x /etc/sysconfig/network-scripts/ifcfg-eth0:1
sudo ifconfig eth0:1 up
Se você só quiser testar, execute (mas ele não sobreviverá à reinicialização do sistema):
sudo ifconfig eth0:1 10.0.0.254
Dependendo do SO, talvez seja preciso executar o seguinte:
ifconfig eth0:1
systemctl restart network
{
"roleName": "custom_nic_write",
"description": "IRIS Role to assign VIP",
"assignableScopes": [
"/subscriptions/{subscriptionid}/resourceGroups/{resourcegroupid}/providers/Microsoft.Network/networkInterfaces/{nicid_primary}",
"/subscriptions/{subscriptionid}/resourceGroups/{resourcegroupid}/providers/Microsoft.Network/networkInterfaces/{nicid_backup}"
],
"permissions": [
{
"actions": [
"Microsoft.Network/networkInterfaces/write",
"Microsoft.Network/networkInterfaces/read"
],
"notActions": [],
"dataActions": [],
"notDataActions": []
}
]
}
Para ambientes que não sejam de produção, você pode usar uma função de sistema contribuidor de rede no grupo de recursos, mas essa abordagem não é recomendada, já que contribuidor de rede é uma função muito ampla.
Aqui estão os comandos de CLI do Azure para ambos os nós, considerando o grupo de recursos "rg", a configuração de IP "vip" e o IP externo "my_vip_ip":
az login --identity
az network nic ip-config delete --resource-group rg --name vip --nic-name mirrorb280_z2
az network nic ip-config create --resource-group rg --name vip --nic-name mirrora290_z1 --private-ip-address 10.0.0.254 --public-ip-address my_vip_ip
e:
az login --identity
az network nic ip-config delete --resource-group rg --name vip --nic-name mirrora290_z1
az network nic ip-config create --resource-group rg --name vip --nic-name mirrorb280_z2 --private-ip-address 10.0.0.254 --public-ip-address my_vip_ip
E o mesmo código como uma rotina "ZMIRROR":
ROUTINE ZMIRROR
NotifyBecomePrimary() PUBLIC {
#include %occMessages
set rg = "rg"
set config = "vip"
set privateVIP = "10.0.0.254"
set publicVIP = "my_vip_ip"
set nic = "mirrora290_z1"
set otherNIC = "mirrorb280_z2"
if ##class(SYS.Mirror).DefaultSystemName() [ "MIRRORB" {
// estamos no nó mirrorb, troque
set $lb(nic, otherNIC)=$lb(otherNIC, nic)
}
set rc1 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "login", "--identity")
set rc2 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "network", "nic", "ip-config", "delete", "--resource-group", rg, "--name", config, "--nic-name", otherNIC)
set rc3 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "network", "nic", "ip-config", "create", "--resource-group", rg, "--name", config, "--nic-name", nic, "--private-ip-address", privateVIP, "--public-ip-address", publicVIP)
quit 1
}
A rotina é a mesma para ambos os membros espelho, só trocamos os nomes NIC com base no nome do membro espelho atual. Você talvez não precise de "export AZURE_CONFIG_DIR=/tmp", mas, às vezes, "az" tenta gravar as credenciais no dir home raiz, o que pode falhar. Em vez de "/tmp", é melhor usar o subdiretório home do usuário IRIS (ou talvez você nem precise dessa variável de ambiente, dependendo da sua configuração).
Se você quiser usar o Embedded Python, aqui está o código do SDK Azure para Python:
from azure.identity import DefaultAzureCredential
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.network.models import NetworkInterface, NetworkInterfaceIPConfiguration, PublicIPAddress
sub_id = "AZURE_SUBSCRIPTION_ID"
client = NetworkManagementClient(credential=DefaultAzureCredential(), subscription_id=sub_id)
resource_group_name = "rg"
nic_name = "mirrora290_z1"
other_nic_name = "mirrorb280_z2"
public_ip_address_name = "my_vip_ip"
private_ip_address = "10.0.0.254"
vip_configuration_name = "vip"
# remova a configuração VIP antiga
nic: NetworkInterface = client.network_interfaces.get(resource_group_name, other_nic_name)
ip_configurations_old_length = len(nic.ip_configurations)
nic.ip_configurations[:] = [ip_configuration for ip_configuration in nic.ip_configurations if
ip_configuration.name != vip_configuration_name]
if ip_configurations_old_length != len(nic.ip_configurations):
poller = client.network_interfaces.begin_create_or_update(
resource_group_name,
other_nic_name,
nic
)
nic_info = poller.result()
# adicione a nova configuração VIP
nic: NetworkInterface = client.network_interfaces.get(resource_group_name, nic_name)
ip: PublicIPAddress = client.public_ip_addresses.get(resource_group_name, public_ip_address_name)
vip = NetworkInterfaceIPConfiguration(name=vip_configuration_name,
private_ip_address=private_ip_address,
private_ip_allocation_method="Static",
public_ip_address=ip,
subnet=nic.ip_configurations[0].subnet)
nic.ip_configurations.append(vip)
poller = client.network_interfaces.begin_create_or_update(
resource_group_name,
nic_name,
nic
)
nic_info = poller.result()
"NotifyBecomePrimary" também é chamado automaticamente na inicialização do sistema (após a reconexão do espelho), mas, se você quiser que seus ambientes não espelhados adquiram o VIP da mesma maneira, use a rotina ZSTART:
SYSTEM() PUBLIC {
if '$SYSTEM.Mirror.IsMember() {
do NotifyBecomePrimary^ZMIRROR()
}
quit 1
}
E é isso! Mudamos a configuração de IP que aponta para um espelho primário atual quando ocorre o evento "NotifyBecomePrimary".
Olá Comunidade,
Assista ao novo vídeo no canal InterSystems developers no YouTube:
.png)
Olá, Comunidade,
Neste artigo, vou apresentar meu aplicativo iris-mlm-explainer
Esse aplicativo da Web se conecta ao InterSystems Cloud SQL para criar, treinar, validar e prever modelos de ML, fazer previsões e mostrar um painel com todos os modelos treinados e uma explicação sobre o funcionamento de um modelo de machine learning ajustado. O painel fornece plotagens interativas de desempenho do modelo, importância do recurso, contribuições do recurso para previsões individuais, plotagens de dependência parcial, valores SHAP (interação), visualização de árvores de decisões individuais etc.
Vamos seguir as etapas abaixo para criar e visualizar o painel explicativo de um modelo:
Etapa 1 : fazer o git pull/clone do repositório
Etapa 2 : fazer login no portal de serviços do InterSystems Cloud SQL
Etapa 3 : ativar o ambiente virtual do Python
Etapa 4 : executar o aplicativo da Web para previsão
Etapa 5 : explorar e o painel explicativo
Então, vamos começar com a primeira etapa
Crie uma pasta e faça o git pull/clone do repositório em qualquer diretório local
git clone https://github.com/mwaseem75/iris-mlm-explainer.gitFaça login no InterSystems Cloud Service Portal
Selecione a implantação executada
Clique em "Add and Manage Files" (Adicionar e gerenciar arquivos)
O repositório contém os arquivos USA_Housing_tables_DDL.sql(DDL para criar tabelas), USA_Housing_train.csv(dados de treinamento) e USA_Housing_validate.csv(para validação) na pasta de conjuntos de dados. Selecione o botão de upload para adicionar esses arquivos.
Clique em "Import files" (Importar arquivos), no botão de opção das declarações DDL ou DML e no botão "Next" (Próximo)
Clique no botão de opção do Intersystems IRIS e em "Next"
Selecione o arquivo USA_Housing_tables_DDL.sql e pressione o botão para importar arquivos
Clique em "Import" na caixa de diálogo de confirmação para criar a tabela
Clique nas ferramentas da Query em SQL para verificar se as tabelas foram criadas
Clique em "Import files" (Importar arquivos), no botão de opção dos dados CSV e no botão "Next" (Próximo)
Selecione o arquivo USA_Housing_train.csv na lista suspensa, marque para importar o arquivo como linha de cabeçalho, selecione "Field names in header row match column names in selected table" (Os nomes dos campos na linha de cabeçalho correspondem aos nomes das colunas na tabela selecionada) e clique em "Import files"
Clique em "Import" na caixa de diálogo de confirmação
Confira se 4000 linhas foram atualizadas
Repita as mesmas etapas para importar o arquivo USA_Housing_validate.csv, que contém 1500 registros
Clique em "IntegratedML tools" (ferramentas do IntegratedML) e selecione "Create Panel" (Criar painel).
Insira "USAHousingPriceModel" no campo de nome do modelo, selecione a tabela "usa_housing_train" e "Price" no menu suspenso "Field to predict" (Campo para prever). Clique no botão "Create model" para criar o modelo
Selecione "Train Panel" (Treinar painel), escolha "USAHousingPriceModel" na lista suspensa "Model to train" (Modelo a treinar) e insira "USAHousingPriceModel_t1" no campo de nome do modelo a treinar
O modelo será treinado após a conclusão do status de execução
Selecione "Validate Panel" (Validar painel), escolha "USAHousingPriceModel_t1" na lista suspensa "Trained model to validate" (Modelo treinado a validar), selecione "usa_houseing_validate" na lista suspensa "Table to validate model from" (Tabela para validar o modelo) e clique no botão "Validate model" (Validar modelo)
Clique em "Show validation metrics" para ver as métricas
Clique no ícone de gráfico para ver o gráfico "Prediction VS Actual" (Previsão x Real)
O repositório já contém uma pasta de ambiente virtual do python (venv) com as bibliotecas necessárias.
Tudo o que precisamos fazer é ativar o ambiente
No Unix ou MacOS:
$source venv/bin/activateNo Windows:
venv\scripts\activate###Etapa 4 : definir parâmetros de conexão do InterSystems Cloud SQL
O repositório contém o arquivo config.py. Basta abrir e definir os parâmetros
Coloque os mesmos valores usados no InterSystems Cloud SQL
Execute o comando abaixo no ambiente virtual para iniciar nosso aplicativo principal
python app.py
Acesse http://127.0.0.1:5000/ para executar o aplicativo
Insira "Age of house" (Idade da casa), "No of rooms" (Nº de cômodos), "No of bedroom" (Nº de quartos) e "Area population" (População da área) para obter a previsão
Por fim, execute o comando abaixo no ambiente virtual para iniciar nosso aplicativo principal
python expdash.py
Acesse http://localhost:8050/ para executar o aplicativo
O aplicativo listará todos os modelos treinados com nosso "USAHousingPriceModel". Clique no hyperlink "Go to dashboard" (Acessar painel) para visualizar a explicação sobre o modelo
Importância dos recursos. Quais recursos tiveram o maior impacto?
Métricas quantitativas para o desempenho do modelo, Qual é a diferença entre o valor previsto e o observado?
Previsão e Como cada recurso contribuiu para a previsão?
Ajuste os valores dos recursos para mudar a previsão
Resumo Shap, Ordenamento dos recursos por valores shap
Resumo de interações, Ordenamento dos recursos por valor de interação shap
Árvores de decisões, Exibição de árvores de decisões individuais dentro do Random Forest
Obrigado
Com o lançamento do InterSystems IRIS Cloud SQL, estamos recebendo perguntas frequentes sobre como estabelecer conexões seguras por JDBC e outras tecnologias de driver. Temos um ótimo resumo e uma documentação detalhada sobre as tecnologias de driver, mas essa documentação não chega a descrever ferramentas de cliente individuais, como DBeaver, nossa favorita. Neste artigo, vamos descrever as etapas para criar uma conexão segura no DBeaver para sua implantação do Cloud SQL.
Primeiro, faça login no Cloud Services Portal e crie uma implantação do Cloud SQL. Você só precisa se lembrar de marcar a caixa para ativar conexões externas. Tirando isso, todas as configurações padrão devem funcionar bem.
Para uma conexão segura, vamos usar certificados para criptografar tudo o que é enviado por ela. Você pode baixar o certificado na página de detalhes da implantação pelo botão "Get X.509 certificate" (Obter certificado X.509):
.png)
Em seguida, precisamos armazenar esse certificado em um keystore confiável usando o utilitário keytool. Essa é uma parte padrão da infraestrutura Java, então nada é específico ao IRIS ou ao DBeaver até aqui. Use o comando abaixo para importar o certificado. A localização do arquivo do certificado certificateSQLaaS.pem não importa após executar esse comando, então ele pode ser excluído da pasta de downloads depois. Porém, a localização do arquivo keystore.jks importa. Portanto, execute o comando a partir de uma pasta que faça sentido: onde você continuará a usá-lo para outros fins ou na pasta de instalação do DBeaver, caso seja a única finalidade desse keystore.
keytool -importcert -file path-to-cert/cert-file.pem -keystore keystore.jksPara mais detalhes, veja a documentação.
Em seguida, precisamos dizer ao driver JDBC do IRIS como encontrar esse keystore, o que é feito através de um arquivo SSLConfig.properties. Esse arquivo de texto simples precisa ser colocado no diretório de trabalho do programa Java que abrirá a conexão JDBC. No Windows, é o %LOCALAPPDATA%\DBeaver, que se traduz em C:\Users\<you>\AppData\Local\DBeaver. No Mac, é geralmente /Applications/DBeaverEE.app/Contents/MacOS. Como alternativa, você também pode criar o arquivo em outro lugar e definir o caminho completo como uma variável de ambiente chamada com.intersystems.SSLConfigFile.
Na sua forma mais simples, esse arquivo só precisa apontar para o keystore e incluir a senha. O caminho do arquivo keystore.jks precisa ter o escape adequado para a leitura pelo Java, então você precisará usar barras invertidas duplas no Windows.
trustStore=/path/to/keystore/keystore.jks
trustStorePassword=keystore-passwordHá várias configurações adicionais que você pode definir através desse arquivo descritas na documentação, incluindo configurações do named, mas a indicada acima é suficiente.
Agora que instalamos o certificado e especificamos onde o JDBC do IRIS pode encontrá-lo, podemos criar a conexão do DBeaver. Todas as configurações da guia "Main" no diálogo de criação da conexão podem ser encontradas na tela de detalhes da implementação conforme colada acima:
.png)
Só falta dizer para o DBeaver ativar a criptografia definindo o "connection security level" (nível de segurança da conexão) como 10 na guia "Driver properties" (Propriedades do driver):
.png)
É isso! Ao clicar em "Test Connection" (Testar conexão), você deve obter um polegar para cima ou uma mensagem de erro útil. No segundo caso, confira esta documentação para solução de problemas se não for óbvio o que deve ser alterado.
Se você estiver usando o Mac, parece que há um bug no DBeaver em que o exposto acima pode não ser suficiente. A solução não é convencional, mas funciona. No campo Database/Schema, onde você normalmente colocaria 'USER', insira toda esta string:
USER:sslConnection=true;sslTrustStoreLocation=/pathToTruststore/truststore.jks;sslTrustStorePassword=123456;Dica e outras sabedorias de @Rick Guidice
Olá Comunidade!
Quero compartilhar com vocês uma nova abordagem para solucionar os desafios de otimizar o gerenciamento de dados da InterSystems: o InterSystems TotalView™ For Asset Management, que oferece uma maneira melhor de integrar e transformar dados, criando uma fonte única, confiável e oportuna, para impulsionar decisões críticas.
A InterSystems tomou a decisão de interromper o desenvolvimento do InterSystems Cloud Manager e rotulá-lo como obsoleto a partir do lançamento do InterSystems IRIS 2023.3. A InterSystems continuará a oferecer suporte aos clientes existentes que utilizam a tecnologia, mas ela não é mais recomendada para novas implantações.
Os clientes na nuvem que estão interessados em implantar e gerenciar uma implantação IRIS com muitos sistemas são incentivados a considerar o Kubernetes e o InterSystems Kubernetes Operator, que possui funcionalidade muito semelhante ao ICM.
Neste artigo, vou tentar explicar a etapa de implantação do IAM no meu EC2(ubuntu).
IAM é o InterSystems API Manager
consulte o link abaixo para saber mais sobre o IAM
https://docs.intersystems.com/components/csp/docbook/Doc.View.cls?KEY=PAGE_apimgr
.png)
.png)
.png)
.png)
https://community.intersystems.com/post/introducing-intersystems-api-manager
https://wrc.intersystems.com/wrc/coDistGen.csp
Fiz o download da seguinte versão no meu PC
.png)
Usei o comando scp para fazer upload da imagem na minha nuvem
.png)
Caso contrário, acesse o link a seguir
https://docs.docker.com/engine/install/ubuntu/
tar zpxvf IAM-3.0.2.0-4.tar.gz
.png)
sudo docker load -i iam_image.tar
.png)
source ./iam-setup.sh
.png)
.png)
Para que seja possível acessar a IU do IAM pelo ambiente fora do EC2, substitua o localhost pelo endereço público do EC2 no parâmetro KONG_PORTAL_GUI_HOST e KONG_ADMIN_GUI_URL
vi docker-compose.yml
.png)
sudo docker compose up -d
.png)
Acesse a IU do IAM pelo link a seguir
http://yourEC2publicAddress:8002/overview
.png)
Apache Superset é uma plataforma moderna de exploração e visualização de dados. O Superset pode substituir ou trazer ganhos para as ferramentas proprietárias de business intelligence para muitas equipes. O Superset integra-se bem com uma variedade de fontes de dados.
E agora é possível usar também com o InterSystems IRIS.
Uma demo online está disponível e usa IRIS Cloud SQL como sua fonte de dados.
.png)
Olá Comunidade,
Assista a este vídeo para ver como se conectar ao InterSystems Cloud Services a partir de seu aplicativo Python usando a interface do driver InterSystems DB-API:
O InterSystems Kubernetes Operator (IKO) 3.5 agora está disponível para todos. O IKO 3.5 adiciona novas funcionalidades significativas junto com inúmeras correções de bugs. Os destaques incluem:
Olá Comunidade,
Assista a este vídeo para ver como se conectar ao InterSystems Cloud Services a partir de seu aplicativo Java usando o driver InterSystems JDBC:
Nesta série de artigos, quero apresentar e discutir várias abordagens possíveis para o desenvolvimento de software com tecnologias da InterSystems e do GitLab. Vou cobrir tópicos como:
Neste artigo, vamos desenvolver a entrega contínua com o InterSystems Cloud Manager. O ICM é uma solução de provisionamento e implantação na nuvem para aplicativos baseados no InterSystems IRIS. Ele permite definir a configuração de implantação desejada e o ICM provisiona de maneira automática. Para mais informações, consulte First Look: ICM.
Na nossa configuração de entrega contínua:
Ou em formato gráfico:
Como você pode ver, é praticamente igual, exceto que usaríamos o ICM em vez de gerenciar os contêineres do Docker manualmente.
Antes de atualizar os contêineres, eles devem ser provisionados. Para isso precisamos definir defaults.json e definitions.json, descrevendo nossa arquitetura. Vou fornecer esses 2 arquivos para um servidor LIVE, as definições para um servidor TEST são as mesmas, e os padrões são os mesmos, exceto para os valores Tag e SystemMode.
{
"Provider": "GCP",
"Label": "gsdemo2",
"Tag": "LIVE","SystemMode": "LIVE",
"DataVolumeSize": "10",
"SSHUser": "sample",
"SSHPublicKey": "/icmdata/ssh/insecure.pub",
"SSHPrivateKey": "/icmdata/ssh/insecure",
"DockerImage": "eduard93/icmdemo:master",
"DockerUsername": "eduard93",
"DockerPassword": "...",
"TLSKeyDir": "/icmdata/tls",
"Credentials": "/icmdata/gcp.json",
"Project": "elebedyu-test",
"MachineType": "n1-standard-1",
"Region": "us-east1",
"Zone": "us-east1-b",
"Image": "rhel-cloud/rhel-7-v20170719",
"ISCPassword": "SYS",
"Mirror": "false"
}
[
{
"Role": "DM",
"Count": "1",
"ISCLicense": "/icmdata/iris.key"
}
]Dentro do contêiner ICM, a pasta /icmdata é montada a partir do host e:
Depois de obter todas as chaves necessárias:
keygenSSH.sh /icmdata/ssh keygenTLS.sh /icmdata/tls
E colocar os arquivos necessários em /icmdata:
Chame o ICM para provisionar suas instâncias:
cd /icmdata/test icm provision icm run cd /icmdata/live icm provision icm run
Um servidor TEST e um servidor LIVE seriam provisionados com uma instância do InterSystems IRIS independente em cada um.
Consulte ICM First Look para ver um guia mais detalhado.
Primeiro, precisamos criar nossa imagem.
Nosso código seria, como sempre, armazenado no repositório, a configuração de CD em gitlab-ci.yml. No entanto, além disso (para aumentar a segurança), armazenaríamos vários arquivos específicos do servidor em um servidor de compilação.
Chave de licença. Como alternativa, ela pode ser baixada durante a compilação do contêiner em vez de armazenada em um servidor. É bastante arriscado armazenar no repositório.
Arquivo contendo a senha padrão. Novamente, é bastante arriscado armazená-lo no repositório. Além disso, se você estiver hospedando um ambiente de produção em um servidor separado, ele poderá ter uma senha padrão diferente.
O script inicial:
set dir = ##class(%File).NormalizeDirectory($system.Util.GetEnviron("CI_PROJECT_DIR"))
do ##class(%SYSTEM.OBJ).Load(dir _ "Installer/Global.cls","cdk")
do ##class(Installer.Global).init()
haltObserve que a primeira linha é deixada em branco de maneira intencional.
Várias coisas diferem dos exemplos anteriores. Em primeiro lugar, não habilitamos a autenticação do SO, pois o ICM interagiria com o contêiner em vez do GitLab diretamente. Segundo, estou usando o manifesto do instalador para inicializar nosso aplicativo para mostrar diferentes abordagens de inicialização. Leia mais sobre o Instalador neste artigo. Por fim, publicaremos nossa imagem em um Docher Hub como um repositório privado.
Nosso manifesto do instalador fica desta forma:
E implementa as seguintes mudanças:
Agora, para a configuração da entrega contínua:
build image:
stage: build
tags:
- master
script:
- cp -r /InterSystems/mount ci
- cd ci
- echo 'SuperUser' | cat - pwd.txt load_ci_icm.script > temp.txt
- mv temp.txt load_ci.script
- cd ..
- docker build --build-arg CI_PROJECT_DIR=$CI_PROJECT_DIR -t eduard93/icmdemo:$CI_COMMIT_REF_NAME .O que está acontecendo aqui?
Primeiro, como o docker build pode acessar apenas subdiretórios de um diretório de compilação base — na raiz do repositório do nosso caso, precisamos copiar nosso diretório "secreto" (aquele com iris.key, pwd.txt e load_ci_icm.script) no repositório clonado.
Em seguida, o primeiro acesso ao terminal requer um usuário/senha, então nós os adicionamos a load_ci.script (por isso a linha vazia no início de load_ci.script).
Por fim, criamos a imagem do docker e a marcamos adequadamente: eduard93/icmdemo:$CI_COMMIT_REF_NAME
onde $CI_COMMIT_REF_NAME é o nome de um branch atual. Observe que a primeira parte da tag de imagem deve ter o mesmo nome do nome do projeto no GitLab, para que possa ser vista na guia GitLab Registry (instruções sobre a marcação estão disponíveis na guia Registry).
A criação de uma imagem docker é feita usando o Dockerfile:
FROM intersystems/iris:2018.1.1-released ENV SRC_DIR=/tmp/src ENV CI_DIR=$SRC_DIR/ci ENV CI_PROJECT_DIR=$SRC_DIR COPY ./ $SRC_DIR RUN cp $CI_DIR/iris.key $ISC_PACKAGE_INSTALLDIR/mgr/ \ && cp $CI_DIR/GitLab.xml $ISC_PACKAGE_INSTALLDIR/mgr/ \ && $ISC_PACKAGE_INSTALLDIR/dev/Cloud/ICM/changePassword.sh $CI_DIR/pwd.txt \ && iris start $ISC_PACKAGE_INSTANCENAME \ && irissession $ISC_PACKAGE_INSTANCENAME -U%SYS < $CI_DIR/load_ci.script \ && iris stop $ISC_PACKAGE_INSTANCENAME quietly
Começamos a partir do contêiner básico iris.
Primeiro, copiamos nosso repositório (e diretório "secreto") dentro do contêiner.
Em seguida, copiamos a chave de licença para o diretório mgr.
Em seguida, alteramos a senha para o valor de pwd.txt. Observe que pwd.txt é excluído nessa operação.
Depois disso, a instância é iniciada e load_ci.script é executado.
Por fim, a instância iris é interrompida.
Estou usando o executor GitLab Shell, e não o executor Docker. O executor Docker é usado quando você precisa de algo de dentro da imagem, por exemplo, você está criando um aplicativo Android em um contêiner java e precisa apenas de um apk. No nosso caso, precisamos de um contêiner inteiro e, para isso, precisamos do executor Shell. Então, estamos executando comandos do Docker pelo executor GitLab Shell.
Agora, vamos publicar nossa imagem em um Docker Hub
publish image:
stage: publish
tags:
- master
script:
- docker login -u eduard93 -p ${DOCKERPASSWORD}
- docker push eduard93/icmdemo:$CI_COMMIT_REF_NAMEObserve a variável ${DOCKERPASSWORD}, é uma variável secreta do GitLab. Podemos adicioná-la em GitLab > Project > Settings > CI/CD > Variables:
Os logs de job também não contêm valor de senha:
Running with gitlab-runner 10.6.0 (a3543a27)
on icm 82634fd1
Using Shell executor...
Running on docker...
Fetching changes...
Removing ci/
HEAD is now at 8e24591 Add deploy to LIVE
Checking out 8e245910 as master...Skipping Git submodules setup$ docker login -u eduard93 -p ${DOCKERPASSWORD}
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
Login Succeeded
$ docker push eduard93/icmdemo:$CI_COMMIT_REF_NAME
The push refers to repository [docker.io/eduard93/icmdemo]
master: digest: sha256:d1612811c11154e77c84f0c08a564a3edeb7ddbbd9b7acb80754fda97f95d101 size: 2620
Job succeeded
e no Docker Hub podemos ver nossa nova imagem:
Temos nossa imagem, agora vamos executá-la em nosso servidor de teste. Aqui está o script.
run image:
stage: run
environment:
name: $CI_COMMIT_REF_NAME
tags:
- master
script:
- docker exec icm sh -c "cd /icmdata/test && icm upgrade -image eduard93/icmdemo:$CI_COMMIT_REF_NAME"Com o ICM, precisamos executar apenas um comando (icm upgrade) para fazer upgrade da implantação existente. Estamos chamando-a executando "docker exec icm sh -c ", que executa um comando especificado dentro do contêiner icm. Primeiro, entramos no modo /icmdata/test, onde a definição da implantação do ICM é configurada para um servidor TEST. Depois disso, chamamos icm upgrade para substituir o contêiner existente por um novo contêiner.
Vamos fazer alguns testes.
test image:
stage: test
tags:
- master
script:
- docker exec icm sh -c "cd /icmdata/test && icm session -namespace USER -command 'do \$classmethod(\"%UnitTest.Manager\",\"RunTest\",\"MyApp/Tests\",\"/nodelete\")' | tee /dev/stderr | grep 'All PASSED' && exit 0 || exit 1"
Novamente, estamos executando um comando dentro do nosso contêiner icm. A sessão icm executa um comando em um nó implantado. O comando executa testes de unidade. Depois disso, ele canaliza todos os resultados para a tela e também para o grep para encontrar os resultados dos testes de unidade e sair do processo com sucesso ou com um erro.
A implantação em um servidor de produção é absolutamente igual à implantação em teste, exceto por outro diretório para a definição da implantação LIVE. Se os testes falhassem, essa etapa não seria executada.
deploy image:
stage: deploy
environment:
name: $CI_COMMIT_REF_NAME
tags:
- master
script:
- docker exec icm sh -c "cd /icmdata/live && icm upgrade -image eduard93/icmdemo:$CI_COMMIT_REF_NAME"Olá Desenvolvedores,
Assista a este vídeo para saber como usar o InterSystems IRIS Cloud IntegratedML:
Function as a service (FaaS) é uma categoria de serviços de computação na nuvem que disponibiliza uma plataforma que permite que os clientes desenvolvam, executem e gerenciem as funcionalidades das aplicações sem que tenham a complexidade de construir e manter a infraestrutura tipicamente associada a se desenvolver e lançar um app. Construir uma aplicação seguindo este modelo é uma das formas de se alcançar uma arquitetura "serverless" e é tipicamente utilizada quando se constroem aplicações baseadas em microsserviços.
FaaS é uma abordagem extremamente popular para se executar cargas de trabalho na nuvem, permitindo que os desenvolvedores mantenham o foco na escrita de códigos.
Este artigo irá mostrar-lhe como implantar métodos do InterSystems IRIS na forma FaaS.
Da última vez, lançamos uma aplicação IRIS no Google Cloud usando seu serviço GKE.
E, embora criar um cluster manualmente (ou por meio do gcloud) seja fácil, a abordagem de Infraestrutura como Código (IaC) moderna recomenda que a descrição do cluster Kubernetes também seja armazenada no repositório como código. Como escrever este código é determinado pela ferramenta que é usada para IaC.
No caso do Google Cloud, existem várias opções, entre elas o Deployment Manager e o Terraform. As opiniões estão divididas quanto o que é melhor: se você quiser saber mais, leia este tópico no Reddit Opiniões sobre Terraform vs. Deployment Manager? e o artigo no Medium Comparando o GCP Deployment Manager e o Terraform.
Para este artigo, escolheremos o Terraform, já que ele está menos vinculado a um fornecedor específico e você pode usar seu IaC com diferentes provedores em nuvem.
Suporemos que você leu o artigo anterior e já tem uma conta do Google, e que criou um projeto chamado “Desenvolvimento”, como no artigo anterior. Neste artigo, seu ID é mostrado como
Lembre-se de que o Google não é gratuito, embora tenha um nível gratuito. Certifique-se de controlar suas despesas.
Também presumiremos que você já bifurcou o repositório original. Chamaremos essa bifurcação (fork) de “my-objectscript-rest-docker-template” e nos referiremos ao seu diretório raiz como
Todos os exemplos de código são armazenados neste repositório para simplificar a cópia e a colagem.
O diagrama a seguir descreve todo o processo de implantação em uma imagem:
.png)
Então, vamos instalar a versão mais recente do Terraform no momento desta postagem:
A versão é importante aqui, pois muitos exemplos na Internet usam versões anteriores, e a 0.12 trouxe muitas mudanças.
Queremos que o Terraform execute certas ações (use certas APIs) em nossa conta do GCP. Para ativar isso, crie uma conta de serviço com o nome 'terraform' e ative a API do Kubernetes Engine. Não se preocupe sobre como vamos conseguir isso — basta continuar lendo e suas perguntas serão respondidas.
Vamos tentar um exemplo com o utilitário gcloud, embora também possamos usar o console web.
Usaremos alguns comandos diferentes nos exemplos a seguir. Consulte os tópicos da documentação a seguir para obter mais detalhes sobre esses comandos e recursos.
Agora vamos analisar o exemplo.
Como trabalhamos com o gcloud no artigo anterior, não discutiremos todos os detalhes de configuração aqui. Para este exemplo, execute os seguintes comandos:
Agora, vamos adicionar alguns papéis à conta de serviço do terraform além de “Administrador do Kubernetes Engine” (container.admin). Essas funções serão úteis para nós no futuro.
$ gcloud projects add-iam-policy-binding
--member serviceAccount:terraform@
--role roles/iam.serviceAccountUser
$ gcloud projects add-iam-policy-binding
--member serviceAccount:terraform@
--role roles/compute.viewer
$ gcloud projects add-iam-policy-binding
--member serviceAccount:terraform@
--role roles/storage.admin
$ gcloud iam service-accounts keys create account.json \
--iam-account terraform@
Observe que a última entrada cria o seu arquivo account.json. Certifique-se de manter este arquivo em segredo.
A seguir, vamos descrever o cluster GKE na linguagem HCL do Terraform. Observe que usamos vários placeholders aqui; substitua-os por seus valores:
| Placeholder |
Aqui está a configuração HCL para o cluster na prática:
provider "google" {
credentials = file("account.json")
project = "
region = "
}
resource "google_container_cluster" "gke-cluster" {
name = "
location = "
remove_default_node_pool = true
# No cluster regional (localização é região, não zona)
# este é um número de nós por zona
initial_node_count = 1
}
resource "google_container_node_pool" "preemptible_node_pool" {
name = "
location = "
cluster = google_container_cluster.gke-cluster.name
# No cluster regional (localização é região, não zona)
# este é um número de nós por zona
node_count = 1
node_config {
preemptible = true
machine_type = "n1-standard-1"
oauth_scopes = [
"storage-ro",
"logging-write",
"monitoring"
]
}
}
Para garantir que o código HCL esteja no formato adequado, o Terraform fornece um comando de formatação útil que você pode usar:
O fragmento de código (snippet) mostrado acima indica que os recursos criados serão fornecidos pelo Google e os próprios recursos são google_container_cluster e google_container_node_pool, que designamos como preemptivos para economia de custos. Também optamos por criar nosso próprio pool em vez de usar o padrão.
Vamos nos concentrar brevemente na seguinte configuração:
O Terraform grava tudo o que é feito no arquivo de status e usa esse arquivo para outro trabalho. Para um compartilhamento conveniente, é melhor armazenar este arquivo em algum lugar remoto. Um lugar típico é umGoogle Bucket.
Vamos criar este bucket. Use o nome do seu bucket em vez do placeholder
Boa resposta:
A resposta ocupado "Busy" significa que você deve escolher outro nome:
Também vamos habilitar o controle de versão, como o Terraform recomenda.
$ gsutil versioning get gs://
gs://
$ gsutil versioning set on gs://
$ gsutil versioning get gs://
gs://
O Terraform é modular e precisa adicionar um plugin de provedor do Google para criar algo no GCP. Usamos o seguinte comando para fazer isso:
Vejamos o que o Terraform fará para criar um cluster do GKE:
A saída do comando inclui detalhes do plano. Se você não tem objeções, vamos implementar este plano:
A propósito, para excluir os recursos criados pelo Terraform, execute este comando a partir do
Vamos deixar o cluster como está por um tempo e seguir em frente. Mas primeiro observe que não queremos colocar tudo no repositório, então vamos adicionar vários arquivos às exceções:
Usando Helm
No artigo anterior, armazenamos os manifestos do Kubernetes como arquivos YAML no
Desta vez, tentaremos uma abordagem diferente: usando o gerenciador de pacotes Helm do Kubernetes, que foi atualizado recentemente para a versão 3. Use a versão 3 ou posterior porque a versão 2 tinha problemas de segurança do lado do Kubernetes (veja Executando o Helm na produção: melhores práticas de Segurança para mais detalhes). Primeiro, empacotaremos os manifestos Kubernetes de nosso diretório k8s/ em um pacote Helm, que é conhecido como chart. Um chart Helm instalado no Kubernetes é chamado de release. Em uma configuração mínima, um chart consistirá em vários arquivos:
Seu propósito está bem descrito no site oficial. As práticas recomendadas para criar seus próprios charts são descritas no Guia de Melhores Práticas do Chart na documentação do Helm.
Esta é a aparência do conteúdo de nossos arquivos:
{{- define "iris-rest.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}}
{{- end -}}
{{/*
Cria o nome e a versão do chart conforme usado pelo rótulo do chart.
*/}}
{{- define "iris-rest.chart" -}}
{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
{{- end -}}
replicaCount: 1
strategy: |
type: Recreate
image:
repository: eu.gcr.io/iris-rest
tag: v1
webPort:
name: web
value: 52773
service:
enabled: true
name: iris-rest
type: LoadBalancer
loadBalancerIP: ""
ports:
web:
port: 52773
targetPort: 52773
protocol: TCP
Para criar os charts do Helm, instaleo cliente Helm e o utilitário de linha de comando kubectl.
Crie um namespace chamado iris. Seria bom se isso fosse criado durante a implantação, mas até agora não é o caso.
Primeiro, adicione credenciais para o cluster criado pelo Terraform ao kube-config:
Confirme (sem iniciar uma implantação real) se o Helm criará o seguinte no Kubernetes:
A saída — os manifestos do Kubernetes — foi omitida por causa do espaço aqui. Se tudo estiver certo, vamos implantar:
Vemos que o Helm implantou nossa aplicação, mas como ainda não criamos a imagem Docker eu.gcr.io/iris-rest:v1, o Kubernetes não pode extraí-la (ImagePullBackOff):
Vamos terminar com isso por agora:
O Lado do CircleCI
Agora que experimentamos o Terraform e o cliente Helm, vamos colocá-los em uso durante o processo de implantação no lado do CircleCI.
orbs:
gcp-gcr: circleci/gcp-gcr@0.6.1
jobs:
terraform:
docker:
# A versão da imagem do Terraform deve ser a mesma de quando
# você executa o terraform antes da máquina local
- image: hashicorp/terraform:0.12.17
steps:
- checkout
- run:
name: Create Service Account key file from environment variable
working_directory: terraform
command: echo ${TF_SERVICE_ACCOUNT_KEY} > account.json
- run:
name: Show Terraform version
command: terraform version
- run:
name: Download required Terraform plugins
working_directory: terraform
command: terraform init
- run:
name: Validate Terraform configuration
working_directory: terraform
command: terraform validate
- run:
name: Create Terraform plan
working_directory: terraform
command: terraform plan -out /tmp/tf.plan
- run:
name: Run Terraform plan
working_directory: terraform
command: terraform apply /tmp/tf.plan
k8s_deploy:
docker:
- image: kiwigrid/gcloud-kubectl-helm:3.0.1-272.0.0-218
steps:
- checkout
- run:
name: Authorize gcloud on GKE
working_directory: helm
command: |
echo ${GCLOUD_SERVICE_KEY} > gcloud-service-key.json
gcloud auth activate-service-account --key-file=gcloud-service-key.json
gcloud container clusters get-credentials ${GKE_CLUSTER_NAME} --zone ${GOOGLE_COMPUTE_ZONE} --project ${GOOGLE_PROJECT_ID}
- run:
name: Wait a little until k8s worker nodes up
command: sleep 30 # It’s a place for improvement
- run:
name: Create IRIS namespace if it doesn't exist
command: kubectl get ns iris || kubectl create ns iris
- run:
name: Run Helm release deployment
working_directory: helm
command: |
helm upgrade iris-rest \
--install \
. \
--namespace iris \
--wait \
--timeout 300s \
--atomic \
--set image.repository=eu.gcr.io/${GOOGLE_PROJECT_ID}/iris-rest \
--set image.tag=${CIRCLE_SHA1}
- run:
name: Check Helm release status
command: helm list --all-namespaces --all
- run:
name: Check Kubernetes resources status
command: |
kubectl -n iris get pods
echo
kubectl -n iris get services
workflows:
main:
jobs:
- terraform
- gcp-gcr/build-and-push-image:
dockerfile: Dockerfile
gcloud-service-key: GCLOUD_SERVICE_KEY
google-compute-zone: GOOGLE_COMPUTE_ZONE
google-project-id: GOOGLE_PROJECT_ID
registry-url: eu.gcr.io
image: iris-rest
path: .
tag: ${CIRCLE_SHA1}
- k8s_deploy:
requires:
- terraform
- gcp-gcr/build-and-push-image
Você precisará adicionar várias variáveis de ambiente ao seu projeto no lado do CircleCI:
.png)
O GCLOUD_SERVICE_KEY é a chave da conta de serviço CircleCI e o TF_SERVICE_ACCOUNT_KEY é a chave da conta de serviço Terraform. Lembre-se de que a chave da conta de serviço é todo o conteúdo do arquivo account.json.
A seguir, vamos enviar nossas alterações para um repositório:
O painel da IU do CircleCI deve mostrar que tudo está bem:
Terraform é uma ferramenta idempotente e se o cluster GKE estiver presente, o trabalho "terraform" não fará nada. Se o cluster não existir, ele será criado antes da implantação do Kubernetes.
Por fim, vamos verificar a disponibilidade de IRIS:
$ kubectl -n iris get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
Iris-rest LoadBalancer 10.23.249.42 34.76.130.11 52773:31603/TCP 53s
$ curl -XPOST -H "Content-Type: application/json" -u _system:SYS 34.76.130.11:52773/person/ -d '{"Name":"John Dou"}'
$ curl -XGET -u _system:SYS 34.76.130.11:52773/person/all
[{"Name":"John Dou"},]
Conclusão
Terraform e Helm são ferramentas DevOps padrão e devem ser perfeitamente integrados à implantação do IRIS.
Eles exigem algum aprendizado, mas depois de alguma prática, eles podem realmente economizar seu tempo e esforço.
Recentemente, eu estava respondendo a algumas perguntas que alguém tinha sobre alguns bugs que surgem no Docker para Mac, e isso me lembrou o que Shakespeare escreveu em sua famosa tragédia sobre orquestração de software em grande escala, Kubelet: o Príncipe do Benchmark.
Olá Desenvolvedores!
Vocês já tiveram que converter mensagens HL7v2 para FHIR (Fast Healthcare Interoperability Resources) e acharam o processo de transformação complicado e confuso? A InterSystems está criando uma nova oferta de SaaS baseada em nuvem chamada de Serviços de Transformação de Mensagens do HealthShare que faz com que este processo se torne simples. Estamos muito empolgados de anunciar um Programa de Acesso Antecipado para esta nossa nova oferta e adoraríamos que vocês o utilizassem e então nos dessem seu feedback a respeito do mesmo! Para isso basta que vocês possuam uma conta grátis AWS, com um bucket S3 para colocar suas mensagens HL7v2 e outro bucket S3 para colocar a saída em FHIR.
Suponha que você desenvolveu uma nova aplicação utilizando a parte de Interoperabilidade do InterSystems IRIS e você tem certeza de que será um sucesso! No entanto, você ainda não tem um número concreto de quantas pessoas irão utilizá-la. Além disso, pode haver dias específicos em que há mais pessoas utilizando sua aplicação e dias em que quase ninguém irá acessar. Deste modo, você necessita de que sua aplicação seja escalável!
Se você está procurando por uma interodução ao Kubernetes como tecnologia, e uma pequena provocação sobre o InterSystems Kubernetes Operator, dê uma olhada no recém lançado vídeo de Introdução ao Kubernetes. Este vídeo te apresentará a funcionalidade e os casos de uso para o Kubernetes, bem como fará uma breve explicação de como o InterSystems Kubernetes Operator torna vantajoso o uso do Kubernetes com o InterSystems IRIS.
Suponha que você desenvolveu uma nova aplicação utilizando a parte de Interoperabilidade do InterSystems IRIS e você tem certeza de que será um sucesso! No entanto, você ainda não tem um número concreto de quantas pessoas irão utilizá-la. Além disso, pode haver dias específicos em que há mais pessoas utilizando sua aplicação e dias em que quase ninguém irá acessar. Deste modo, você necessita de que sua aplicação seja escalável!