Limpar filtro
Artigo
Davi Massaru Teixeira Muta · Maio 14, 2023
#O problema
Temos o seguinte cenário, você trabalha em um laboratório, que até então atendia apenas exames realizados em uma região geográfica especifica, porém dentro de um curto espaço de tempo, percebe que seu negócio está expandindo para outras regiões, a demanda pela entrega dos resultados dos exames passa a não ser mais suportada pelo servidor principal, quedas e lentidões devido a alta repentina de solicitações, passam a ser mais frequentes e seus clientes passam a reclamar da indisponibilidade do sistema, como lidar com essa situação ?

Obviamente sua aplicação precisa ter a infraestrutura aprimorada, caso esteja utilizando a plataforma de dados InterSystems IRIS/Caché, a utilização de ECP’s pode ser uma saída para o problema.
#ECP
ECP - “Enterprise Cache Protocol” protocolo com arquitetura de cache de dados distribuídos, permite distribuir dados e lógica de aplicativos de forma eficiente em vários sistemas de servidores.
Ao contrário de outras arquiteturas multicamadas, o ECP é uma opção de configuração, que não requer usar código especial ou técnicas de desenvolvimento para criar aplicativos de banco de dados distribuídos, fazendo com que diversos servidores executem a aplicação usando a mesma base de código, permitindo que os desenvolvedores se concentrem na funcionalidade central centrada no cliente, tornando o aplicativo mais simples de manter.
#Configuração ECP’s?
Para compreender a configuração de um E.C.P, é importante entender como os artefatos de código e dados são organizados dentro da plataforma InterSystems IRIS.
#Mapeamento de namespaces.
Namespace é uma unidade lógica de organização em InterSystems IRIS que permite a separação de objetos e recursos do sistema em grupos distintos. Tornando mais fácil a administração e o gerenciamento do sistema.
Cada Namespace é configurado para utilizar banco de dados de globais e rotinas, que é utilizado para armazenar e gerenciar os dados globais e objetos de rotinas.

## - Banco de dados provedor de Globais:
O Banco de dados provedor de globais, é usado para armazenar e gerenciar os dados globais em um determinado namespace.
##- Banco de dados provedor de Rotinas:
Rotinas são artefatos do banco que executam tarefas específicas no sistema, plataformas de dados InterSystems utilizando o provedor de rotinas como um banco de dados especializado para armazenar e gerenciar as rotinas de código em um namespace.
#Realizar os mapeamentos
Para configurar o ECP (Enterprise Cache Protocol), é necessário seguir alguns passos simples. Primeiramente, é preciso instalar uma nova máquina com uma instância de InterSystems IRIS ou Cache. Em seguida, é necessário configurar os servidores de aplicação no servidor de dados e vice-versa, para que o ambas instâncias Intersystems possam se comunicar, podendo configurar e distinguir entre bancos de dados locais e remotos entre as instâncias.
• Banco de dados local: É o banco de dados que reside fisicamente na mesma máquina em que o banco IRIS/Caché está sendo executado, associado a uma instância InterSystmes, sendo acessado e gerenciado pela própria instância do IRIS no servidor local.
• Banco de dados remoto: Banco de dados que está localizado em um servidor separado, ou seja, em uma máquina diferente daquela onde o IRIS está sendo executado.
Em seguida, devemos configurar o E.C.P (novo servidor de aplicação) para utilizar os bancos de dados remotos, provenientes do servidor de dados principal (onde possui os seus apontamentos locais), com a possibilidade de organização do namespace apontar para os bancos de global (dados) e rotinas (código) remotos, seguindo a seguinte estrutura:

Ao configurar o Enterprise Cache Protocol (ECP) e o namespace no InterSystems IRIS com o uso de bancos de dados remotos, ocorre uma distribuição de tarefas e recursos entre o servidor de aplicação (onde está o ECP) e o servidor de dados (onde estão os bancos de dados locais).
#Rede de E.C.Ps:
No cenário de configuração de diversos E.C.P.s com bancos de dados remotos, os processos (JOBs), são executados no servidor de aplicação controlando o fluxo de trabalho e garantindo a escalabilidade e o balanceamento de carga.
No entanto, os dados e as rotinas são armazenados no servidor de dados, onde estão localizados os bancos de dados locais. Ele fornece o armazenamento centralizado para os dados e as rotinas utilizados pelos processos executados no servidor de aplicação.
Essa arquitetura distribuída permite que o processamento e o armazenamento sejam separados, essa configuração permite um ambiente distribuído eficiente, com recursos compartilhados.

Desta forma você pode escalar sua aplicação, para atender uma demanda que seu sistema necessita, sem a alteração de códigos de sua aplicação, a expansão do seu laboratório para outras regiões geográficas pode trazer desafios significativos em relação à capacidade e disponibilidade do sistema. No entanto, a utilização dos ECPs (Enterprise Cache Protocol) no InterSystems IRIS/Caché pode ser solução viável para lidar com essa situação. Ao implementar uma infraestrutura aprimorada e distribuída, é possível alcançar uma maior capacidade de processamento, melhorar o desempenho e garantir a disponibilidade dos resultados dos exames.
Os ECPs permitem uma distribuição eficiente da carga de trabalho, com processos sendo executados nos servidores de aplicação e os dados sendo armazenados nos servidores de dados.
Essa abordagem proporciona uma maior escalabilidade e balanceamento de carga, evitando quedas e lentidões causadas pelo aumento repentino na demanda. Além disso, a infraestrutura distribuída permite a centralização e o gerenciamento eficiente dos dados, facilitando a expansão para novas regiões sem comprometer a qualidade do serviço.
Ao adotar os ECPs no InterSystems IRIS/Caché, você estará preparando sua aplicação para suportar o crescimento e atender às demandas dos clientes em diferentes regiões geográficas. Essa solução proporciona maior escalabilidade e desempenho, permitindo que seu laboratório ofereça um serviço de qualidade, com resultados de exames entregues. Parabéns Davi! Genial, excelente seu artigo. Você vai longe. Parabéns pelo artigo!!! Great article and explanation Davi!! Congrats 🙂
Anúncio
Danusa Calixto · Maio 10, 2023
Olá Comunidade!
Se você não pode se juntar a nós no Encontro On-line sobre o 2º Concurso de Artigos Técnicos em Português da InterSystems poderá assistir à gravação que já está disponível no canal InterSystems Brasil Desenvolvedores do Youtube.
Neste encontro, os Engenheiros de Venda da InterSystems Brasil @Danusa.Ferreira e @Rochael.Ribeiro falaram sobre a InterSystems, a Comunidade de Desenvolvedores e o 2º Concurso de Artigos Técnicos em Português da InterSystems. Foi uma oportunidade de apresentar aos novos membros da comunidade um pouco da InterSystems e seus produtos, a Comunidade de Desenvolvedores e de esclarecer dúvidas sobre o concurso.
⏯ Encontro On-line sobre o 2º Concurso de Artigos Técnicos em Português da InterSystems
Junte-se a nós no canal InterSystems Brasil Desenvolvedores do Youtube também!
Artigo
Madu Gonçalves da Silva · Maio 27, 2023
O problema do grupo Pardini era mudar a plataforma de banco de dados "Nós construímos nosso negócio nele, então você pode imaginar como é arriscado mudar a plataforma de banco de dados abaixo dele. Ao escolhermos o InterSystems IRIS for Health conseguimos o crescimento das operações e de serviços com a velocidade que os negócios exigem", a companhia iniciou o desenvolvimento do sistema de informações laboratoriais (Lis) na plataforma de dados InterSystems Caché,
Enquanto eu estava pesquisando eu li em um site que eles poderiam ter optado por não fazer nenhuma alteração por que o site funcionava bem, mas o desenvolvimento do software Caché tinham sido baseados em uma alta demanda e cada vez mais difíceis de encontrar, Pardini reconheceu o risco para seu crescimento e o futuro do negocio, por isso mudou os dados da plataforma.
Por isso a empresa precisava de uma nova base tecnológica, eles disseram que o python seria melhor para facilitar a contatação dos talentos que precisavam.
O Sr.Marcos Simão, Sales Manager da InterSystems no Brasil, disse que "estamos diante de um grande caso de sucesso, já que esse foi um dos maiores desafios que tivemos em concorrer com outras tecnologias e sermos escolhidos para contribuir para o desenvolvimento de uma das maiores plantas de produção de resultados de exames do mundo".
Com isso vemos que a plataforma InterSystems IRIS ajudou a revolucionar a transformação digital no mercado laboratorial, eu escolhi essa informação por que achei interessante a InterSystems IRIS ter ajudado a revolucionar o mercado, pensando assim a InterSystems IRIS ajudou muito, e isso é tudo.
Anúncio
Danusa Calixto · Jun. 12, 2023
Olá Comunidade!
Está chegando ao fim o 🏆 2º Concurso de Artigos Técnicos em Português da InterSystems 🏆A partir de agora começa o período de votação dos Especialistas da Comunidade, mas a votação da comunidade ainda está valendo.
Todos os artigos serão avaliados e validados de acordo com as regras do concurso, os votos e bonus serão contabilizados, e em breve será divulgado o resultado do concurso.
Desde já a Comunidade de Desenvolvedores PT agradece a todos os participantes, e deseja Boa Sorte a todos! O Concurso está finalizando mas a nossa Comunidade continua ativa e contando com a colaboração de todos vocês.
Continuem ligados nos anúncios e artigos da Comunidade de Desenvolvedores 😉
Artigo
Larissa Prussak · Jun. 17
Se você está migrando do Oracle para o InterSystems IRIS — como muitos dos meus clientes — pode se deparar com padrões específicos de SQL do Oracle que precisam ser adaptados.
Veja esse examplo:
SELECT (TO_DATE('2023-05-12','YYYY-MM-DD') - LEVEL + 1) AS gap_date
FROM dual
CONNECT BY LEVEL <= (TO_DATE('2023-05-12','YYYY-MM-DD') - TO_DATE('2023-05-02','YYYY-MM-DD') + 1);
No Oracle:
LEVEL é uma pseudo-coluna usada em consultas hierárquicas (com CONNECT BY). Ela começa em 1 e incrementa de 1 em 1.
CONNECT BY LEVEL <= (...) define quantas linhas a consulta deve gerar.
A diferença entre as duas datas, somada a 1, resulta em 11 — então a consulta gera 11 linhas, contando de 12 de maio de 2023 para 2 de maio de 2023.
Detalhamento do resultado:
LEVEL = 1 → 2023-05-12
LEVEL = 2 → 2023-05-11
...
LEVEL = 11 → 2023-05-02
Agora a questão é: Como fazer isso no InterSystems IRIS, que não possui CONNECT BY?
Uma solução é implementar uma consulta no estilo SQL usando ObjectScript, simulando esse comportamento. Abaixo está um exemplo de definição CREATE QUERY que aceita uma data inicial (STARTDATE) e um número de dias (DAYS), e retorna a lista decrescente de datas.
✅ InterSystems IRIS: Implementando uma consulta de intervalo de datas
CREATE QUERY GET_GAP_DATE(IN STARTDATE DATE, IN DAYS INT)
RESULTS (GAP_DATE DATE)
PROCEDURE
LANGUAGE OBJECTSCRIPT
Execute(INOUT QHandle BINARY(255), IN STARTDATE DATE, IN DAYS INT)
{
SET QHandle("start") = STARTDATE
SET QHandle("days") = DAYS
SET QHandle("level") = 1
RETURN $$$OK
}
Fetch(INOUT QHandle BINARY(255), INOUT Row %List, INOUT AtEnd INT)
{
IF (QHandle("level") > QHandle("days")) {
SET Row = ""
SET AtEnd = 1
} ELSE {
SET Row = $ListBuild(QHandle("start") - QHandle("level") + 1)
SET QHandle("level") = QHandle("level") + 1
}
RETURN $$$OK
}
Close(INOUT QHandle BINARY(255))
{
KILL QHandle
QUIT $$$OK
}
Você pode executar esse CREATE QUERY no IRIS System Management Portal, ou por ferramentas como DBeaver ou um notebook Python/Jupyter via JDBC/ODBC.
🧪 Examplo de uso:
Para gerar o mesmo resultado da consulta Oracle acima, use:
SELECT * FROM GET_GAP_DATE(
TO_DATE('2023-05-12', 'YYYY-MM-DD'),
TO_DATE('2023-05-12', 'YYYY-MM-DD') - TO_DATE('2023-05-02', 'YYYY-MM-DD') + 1
);
Isso vai gerar:
GAP_DATE
----------
2023-05-12
2023-05-11
...
2023-05-02
(11 rows)
🔁 Uso avançado: junção com outras tabelas
Você também pode utilizar essa consulta como subconsulta ou em JOINs:
SELECT *
FROM GET_GAP_DATE(TO_DATE('2023-05-12', 'YYYY-MM-DD'), 11)
CROSS JOIN dual;
Isso permite integrar intervalos de datas em workflows SQL mais complexos.
Espero que isso ajude quem estiver lidando com cenários de migração de Oracle para IRIS! Se você já criou soluções alternativas ou tiver sugestões de melhorias, adoraria ouvir suas ideias.
Artigo
Vinicius Maranhao Ribeiro de Castro · Out. 7, 2020
Introdução
Hoje em dia existem muitas aplicações que estão usando o Open Authorization framework (OAuth) para acessar recursos de todos os tipos de serviços de maneira segura, confiável e eficiente. O InterSystems IRIS já é compatível com a estrutura OAuth 2.0, na verdade, há um ótimo artigo na comunidade sobre OAuth 2.0 e InterSystems IRIS no seguinte link [aqui](https://community.intersystems.com/post/intersystems-iris-open-authorization-framework-oauth-20-implementation-part-1).
No entanto, com o advento das ferramentas de gerenciamento de API, algumas organizações estão usando-as como um único ponto de autenticação, evitando que solicitações não autorizadas cheguem aos serviços de downstream e desacoplando as complexidades de autorização/autenticação do próprio serviço.
Como você deve saber, a InterSystems lançou sua ferramenta de gerenciamento de API, chamada InterSystems API Management (IAM), que está disponível com a licença IRIS Enterprise (mas não com o IRIS Community Edition). [Aqui](https://community.intersystems.com/post/introducing-intersystems-api-manager) esta outra ótima postagem na comunidade apresentando o InterSystems API Management.
Esta é a primeira parte de uma série de artigos de três partes que mostram como você pode usar o IAM para simplesmente adicionar segurança, de acordo com os padrões do OAuth 2.0, a um serviço não autenticado implantado no IRIS anteriormente.
Nesta primeira parte, serão fornecidos alguns antecedentes do OAuth 2.0 juntamente com algumas definições e configurações iniciais do IRIS e IAM para facilitar a compreensão de todo o processo de proteção de seus serviços.
Após a primeira parte, esta série de artigos abordará dois cenários possíveis para proteger seus serviços com IAM. No primeiro cenário, o IAM validará apenas o token de acesso presente na solicitação de entrada e encaminhará a solicitação para o backend se a validação for bem-sucedida. No segundo cenário, o IAM irá gerar um token de acesso (atuando como um servidor de autorização) e validá-lo.
Portanto, a segunda parte irá discutir e mostrar em detalhes as etapas necessárias para configurar o cenário 1 e a terceira parte irá discutir e demonstrar as configurações do cenário 2, juntamente com algumas considerações finais.
Se você quiser testar o IAM, entre em contato com seu representante de vendas da InterSystems.
OAuth 2.0 - A Experiência
Cada fluxo de autorização OAuth 2.0 consiste basicamente em 4 partes:
1. Usuário
2. Cliente
3. Servidor de Autorização
4. Proprietário do Recurso
Para simplificar, este artigo usará o fluxo OAuth “Credenciais da Senha do Proprietário do Recurso”, mas você pode usar qualquer fluxo OAuth no IAM. Além disso, este artigo não especificará nenhum escopo.
Nota: Você só deve usar o fluxo de Credenciais da Senha do Proprietário do Recurso quando a aplicação cliente for altamente confiável, pois ela lida diretamente com as credenciais do usuário. Na maioria dos casos, o cliente deve ser uma aplicação primária.
Normalmente, o fluxo de Credenciais da Senha do Proprietário do Recurso segue estas etapas:
1. O usuário insere as credenciais (por exemplo, nome de usuário e senha) na aplicação cliente
2. A aplicação cliente envia as credenciais do usuário junto com sua própria identificação (id do cliente e segredo do cliente, por exemplo) para o servidor de autorização. O servidor de autorização valida as credenciais do usuário e a identificação do cliente e retorna um token de acesso
3. O cliente usa o token para acessar recursos no servidor de recursos
4. O servidor de recursos valida o token de acesso recebido antes de retornar qualquer informação ao cliente
Com isso em mente, existem dois cenários em que você pode usar o IAM para lidar com o OAuth 2.0:
1. O IAM atuando como um validador, verificando o token de acesso fornecido pela aplicação cliente, encaminhando a solicitação para o servidor de recursos apenas se o token de acesso for válido. Neste caso, o token de acesso seria gerado por um servidor de autorização de terceiros
2. O IAM atua como um servidor de autorização, fornecendo token de acesso ao cliente, e como um validador de token de acesso, verificando o token de acesso antes de redirecionar a solicitação ao servidor de recursos.
Definições de IRIS e IAM
Nesta postagem, será utilizado uma aplicação IRIS Web denominada “/SampleService”. Como você pode ver na captura de tela abaixo, este é um serviço REST não autenticado implantado no IRIS:
Adicionalmente, é configurado um serviço chamado “SampleIRISService” no lado do IAM contendo uma rota, como você pode ver na imagem abaixo:
Além disso, é configurado um consumidor chamado “ClientApp” no IAM, inicialmente sem nenhuma credencial, para identificar quem está chamando a API no IAM:
Com as configurações acima, o IAM faz proxy para o IRIS a cada solicitação GET enviada para a seguinte URL:
**http://iamhost:8000/event**
Neste ponto, nenhuma autenticação é usada ainda. Portanto, se enviarmos uma solicitação GET simples, sem autenticação, para a URL
**http://iamhost:8000/event/1**
obtemos a resposta desejada.
Neste artigo, vamos usar uma aplicação chamada “PostMan” para enviar solicitações e verificar as respostas. Na captura de tela abaixo do PostMan, você pode ver a solicitação GET simples junto com sua resposta.
Continue lendo até a segunda parte desta série para entender como configurar o IAM para validar os tokens de acesso presentes nas solicitações de entrada.
Artigo
Daniel Kutac · Nov. 19, 2022
Este artigo e os próximos dois artigos da série são um guia do usuário para desenvolvedores ou administradores de sistema que precisam usar o framework OAuth 2.0 (chamado de OAUTH para simplificar) em suas aplicações baseadas no produto InterSystems.
Criado por Daniel Kutac, Engenheiro de vendas sênior, InterSystems
# Histórico de correções e alterações após a publicação
* 3 de agosto de 2016 – Correção da captura de tela da configuração do Google Client; atualização da captura de tela das APIs do Google para refletir a nova versão das páginas.
* 28 de agosto de 2016 – Alterações do código JSON devido às mudanças no suporte ao JSON do Caché 2016.2.
* 3 de maio de 2017 – Atualizações do texto e imagens para refletir a nova interface gráfica e os novos recursos lançados no Caché 2017.1.
* 19 de fevereiro de 2018 – Alteração de Caché para InterSystems IRIS para refletir os desenvolvimentos mais recentes. Porém, é importante salientar que, apesar da alteração do nome do produto, o **artigo aborda todos os produtos da InterSystems**: InterSystems IRIS Data Platform, Ensemble e Caché.
* 17 de agosto de 2020 – Tudo muda, especialmente o software. Consulte o URL do OAuth2 do Google atualizado na resposta do Micholai Mitchko.
_Parte 1. Cliente_
# **Introdução**
Esta é a primeira parte de uma série de três artigos sobre a implementação do Open Authorization Framework na InterSystems.
Nesta primeira parte, apresentamos uma breve introdução do tópico e mostramos um cenário simples em que a aplicação InterSystems IRIS atua como cliente de um servidor de autorização, solicitando alguns recursos protegidos.
A segunda parte descreverá um cenário mais complexo, em que a InterSystems IRIS atua como servidor de autorização e também como servidor de autenticação via OpenID Connect.
A última parte da série descreverá partes individuais das classes do framework OAUTH conforme implementadas pela InterSystems IRIS.
## **Sobre o Open Authorization Framework[1]**
Muitos de vocês já ouviram falar do Open Authorization Framework e para que ele pode ser usado. Vamos resumir para quem ainda não tiver ouvido falar dele.
O Open Authorization Framework, OAUTH, atualmente na versão 2.0, é um protocolo que permite principalmente que aplicações web troquem informações de forma segura estabelecendo uma confiança indireta entre um cliente (aplicação que solicita dados) e o proprietário dos recursos (aplicação que detém os dados solicitados). A confiança é fornecida por uma entidade que tanto o cliente quanto o servidor de recursos reconhecem e na qual confiam. Essa entidade é chamada de servidor de autorização.
Veja um caso de uso simples:
Vamos supor que Jenny (na terminologia do OAUTH, é o proprietário dos recursos) esteja trabalhando em um projeto na empresa JennyCorp. Ela cria um plano de projeto para um possível negócio maior e convida seu parceiro comercial John (usuário cliente) da empresa JohnInc para revisar o documento. Mas ela não está contente de dar ao John acesso à VPN de sua empresa, então ela coloca o documento no Google Drive (o servidor de recursos) ou outra ferramenta de armazenamento em nuvem similar. Ao fazer isso, ela estabeleceu uma confiança entre ela e o Google (o servidor de autorização). Ela compartilha o documento com John (John já usa o serviço Google Drive, e Jenny sabe qual é o e-mail dele).
Quando John deseja ler o documento, ele faz a autenticação em sua conta do Google e, em seu dispositivo móvel (tablet, notebook, etc.), abre um editor de documentos (o servidor cliente) e carrega o arquivo do projeto da Jenny.
Embora pareça bem simples, há muita comunicação entre as duas pessoas e o Google. Todas as comunicações seguem a especificação do OAuth 2.0, então o cliente de John (o leitor de documentos) precisa primeiro fazer a autenticação no Google (essa etapa não é coberta pelo OAUTH) e, após John consentir autorização no formulário fornecido pelo Google, o Google autoriza que o leitor de documentos acesse o documento emitindo um token de acesso. O leitor de documentos usa o token de acesso para emitir uma solicitação ao serviço Google Drive para obter o arquivo de Jenny.
O diagrama abaixo mostra a comunicação entre todas as partes

Nota: embora todas as comunicações do OAUTH 2.0 sejam feitas por solicitações HTTP, os servidores não precisam ser aplicações web.
Vamos ilustrar esse cenário simples com a InterSystems IRIS.
# **Demonstração simples do Google Drive**
Nesta demonstração, vamos criar uma aplicação de pequeno porte baseada em Cloud Solution Provider (CSP) que solicita recursos (lista de arquivos) armazenados no serviço Google Drive com nossa própria conta (e também uma lista de nossos calendários, como bônus).
## **Pré-requisitos**
Antes de começarmos a programar a aplicação, precisamos preparar o ambiente. Precisaremos de um servidor web com SSL ativado e um perfil do Google.
### **Configuração do servidor web**
Conforme informado acima, precisamos estabelecer comunicação com o servidor de autorização com SSL, pois isso é exigido pelo OAuth 2.0 por padrão. Queremos manter nossos dados seguros, certo?
Está fora do escopo deste artigo descrever como configurar um servidor web com suporte ao SSL, então consulte os manuais de usuário do servidor web de sua preferência. Usaremos o servidor IIS da Microsoft neste exemplo específico.
### **Configuração do Google**
Para nos registrarmos no Google, precisamos usar o Google API Manager:
Para o propósito da demonstração, criamos uma conta GlobalSummit2016Demo. É preciso confirmar se a API do Drive está ativada

Agora, está na hora de definir as credenciais

Observe o seguinte:
_Authorized JavaScript (JavaScript autorizado) – permitimos somente scripts originados localmente em relação à página chamadora
_Authorized redirect URIs (URIs de redirecionamento autorizados) – teoricamente, podemos redirecionar nossa aplicação cliente para qualquer site, mas, ao usar a implementação do OAUTH da InterSystems IRIS, precisamos redirecioná-la para **https://localhost/csp/sys/oauth2/OAuth2.Response.cls.** É possível definir vários URIs de redirecionamento autorizados, conforme mostrado na captura de tela, mas, para esta demonstração, só precisamos da segunda entrada.
Por último, precisamos configurar a InterSystems IRIS como cliente do servidor de autorização do Google
### **Configuração do Caché**
A configuração do cliente OAUTH2 da InterSystems IRIS é um processo de duas etapas. Primeiro, precisamos criar uma configuração de servidor.
No SMP, acesse **System Administration (Administração do Sistema) > Security (Segurança) > OAuth 2.0 > Client Configurations (Configurações do cliente)**.
Clique no botão **Create Server Configuration (Criar configuração de servidor)**, preencha o formulário e salve.

Todas as informações inseridas no formulário estão disponíveis no site do console de desenvolvedores do Google. A InterSystems IRIS tem suporte à descoberta automática do Open ID. Entretanto, não estamos usando esse recurso. Inserimos todas as informações manualmente
Agora, clique no link Client Configurations (Configurações do cliente) ao lado do Issuer Endpoint (Endpoint emissor) recém-criado
e clique no botão **Create Client Configuration (Criar configuração de cliente)**.

Deixe as abas Client Information (Informações do cliente) e JWT Settings (Configurações do JWT) em branco (com os valores padrão) e preencha a aba Client credentials (Credenciais do cliente).

Nota: estamos criando um Confidential Client (Cliente confidencial – é mais seguro que o público e significa que o segredo do cliente nunca deixa a aplicação do servidor cliente – nunca é transmitido ao navegador)
Além disso, confirme se **Use SSL/TLS (Usar SSL/TLS)** está marcado e forneça o nome do host (localhost, já que estamos redirecionando localmente para a aplicação cliente) e, posteriormente, a porta e o prefixo (útil quando há várias instâncias da InterSystems IRIS na mesma máquina). Com base nas informações preenchidas, o URL de redirecionamento do cliente é computado e exibido na linha acima.
Na captura de tela acima, fornecemos uma configuração SSL chamada GOOGLE. O nome é usado somente para ajudar a determinar qual configuração SSL dentre várias é usada por esse canal de comunicação específico. O Caché está usando configurações SSL/TLS para armazenar todas as informações necessárias para receber/enviar tráfego seguro ao servidor (neste caso, os URIs OAuth 2.0 do Google).
Consulte mais detalhes na [documentação](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCAS_ssltls#GCAS_ssltls_aboutconfigs).
Preencha os valores Client ID (ID do cliente) e Client Secret (Segredo do cliente) obtidos pelo formulário de definição das credenciais do Google (ao fazer a configuração manual).
Agora, concluímos todas as etapas de configuração e podemos prosseguir para a programação de uma aplicação CSP.
## **Aplicação cliente**
A aplicação cliente é uma aplicação CSP web simples. Ela é composta por um código fonte no servidor, definido e executado pelo servidor web, e uma interface do usuário, exibida ao usuário por um navegador. O exemplo de código fornecido espera que a aplicação cliente seja executada no namespace GOOGLE. Modifique o caminho /csp/google/ para o seu namespace.
## **Servidor cliente**
O servidor cliente é uma aplicação simples de duas páginas. Dentro da aplicação, nós vamos:
· Montar o URL de redirecionamento para o servidor de autorização do Google
· Fazer solicitações à API do Google Drive e à API do Google Agenda e exibir o resultado
### **Página 1**
Esta é uma página da aplicação, na qual decidimos fazer uma chamada aos recursos do Google.
Veja abaixo um código minimalista, mas completamente funcional, que representa a página.
Class Web.OAUTH2.Google1N Extends %CSP.Page
{
Parameter OAUTH2CLIENTREDIRECTURI = "https://localhost/csp/google/Web.OAUTH2.Google2N.cls";
Parameter OAUTH2APPNAME = "Google";
ClassMethod OnPage() As %Status
{
&html<<html>
<head>
</head>
<body style="text-align: center;">
<!-- insert the page content here -->
<h1>Google OAuth2 API</h1>
<p>This page demo shows how to call Google API functions using OAuth2 authorization.
<p>We are going to retrieve information about user and his/her Google Drive files as well as calendar entries.
>
// we need to supply openid scope to authenticate to Google
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
set properties("approval_prompt")="force"
set properties("include_granted_scopes")="true"
set url=##class(%SYS.OAuth2.Authorization).GetAuthorizationCodeEndpoint(..#OAUTH2APPNAME,scope,
..#OAUTH2CLIENTREDIRECTURI,.properties,.isAuthorized,.sc)
w !,"<p><a href='"_url_"'><img border='0' alt='Google Sign In' src='images/google-signin-button.png' ></a>"
&html<</body>
</html>>
Quit $$$OK
}
ClassMethod OnPreHTTP() As %Boolean [ ServerOnly = 1 ]
{
#dim %response as %CSP.Response
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
if ##class(%SYS.OAuth2.AccessToken).IsAuthorized(..#OAUTH2APPNAME,,scope,.accessToken,.idtoken,.responseProperties,.error) {
set %response.ServerSideRedirect="Web.OAUTH2.Google2N.cls"
}
quit 1
}
}
Veja abaixo uma breve explicação do código:
1. Método OnPreHTTP: primeiro, verificamos se, por acaso, já obtivemos um token de acesso válido como resultado de uma autorização do Google. Isso pode acontecer, por exemplo, quando simplesmente atualizamos a página. Caso não tenhamos, precisamos fazer a autorização. Se já tivermos o token, apenas redirecionamos para a página que mostra os resultados
2. Método OnPage: só chegamos a este método se não tivermos um token de acesso válido disponível. Então, precisamos iniciar a comunicação: fazer a autenticação e autorização no Google para que ele nos conceda o token de acesso.
3. Definimos uma string de escopo e uma array de propriedades que modificam o comportamento da janela de autenticação do Google (precisamos fazer a autenticação no Google antes que ele possa nos autorizar com base em nossa identidade).
4. Por último, recebemos o URL de uma página de login do Google e a mostramos ao usuário, seguida pela página de consentimento.
Mais uma nota:
Especificamos a verdadeira página de redirecionamento em no parâmetro OAUTH2CLIENTREDIRECTURI. Entretanto, usamos a página de sistema do framework OAUTH da InterSystems IRIS na definição das credenciais do Google! O redirecionamento é tratado internamente por nossa classe manipuladora OAUTH.
### **Página 2**
Esta página mostra os resultados da autorização do Google e, em caso de êxito, fazemos chamadas à API do Google para obter os dados. Novamente, o código abaixo é minimalista, mas completamente funcional. Deixamos a exibição dos dados recebidos de uma maneira mais estruturada para a imaginação dos leitores.
Include %occInclude
Class Web.OAUTH2.Google2N Extends %CSP.Page
{
Parameter OAUTH2APPNAME = "Google";
Parameter OAUTH2ROOT = "https://www.googleapis.com";
ClassMethod OnPage() As %Status
{
&html<<html>
<head>
</head>
<body>>
// Check if we have an access token
set scope="openid https://www.googleapis.com/auth/userinfo.email "_
"https://www.googleapis.com/auth/userinfo.profile "_
"https://www.googleapis.com/auth/drive.metadata.readonly "_
"https://www.googleapis.com/auth/calendar.readonly"
set isAuthorized=##class(%SYS.OAuth2.AccessToken).IsAuthorized(..#OAUTH2APPNAME,,scope,.accessToken,.idtoken,.responseProperties,.error)
if isAuthorized {
// Google has no introspection endpoint - nothing to call - the introspection endpoint and display result -- see RFC 7662.
w "<h3>Data from <span style='color:red;'>GetUserInfo API</span></h3>"
// userinfo has special API, but could be also retrieved by just calling Get() method with appropriate url
try {
set tHttpRequest=##class(%Net.HttpRequest).%New()
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).AddAccessToken(tHttpRequest,"query","GOOGLE",..#OAUTH2APPNAME))
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).GetUserinfo(..#OAUTH2APPNAME,accessToken,,.jsonObject))
w jsonObject.%ToJSON()
} catch (e) {
w "<h3><span style='color: red;'>ERROR: ",$zcvt(e.DisplayString(),"O","HTML")_"</span></h3>"
}
/******************************************
* *
* Retrieve info from other APIs *
* *
******************************************/
w "<hr>"
do ..RetrieveAPIInfo("/drive/v3/files")
do ..RetrieveAPIInfo("/calendar/v3/users/me/calendarList")
} else {
w "<h1>Not authorized!</h1>"
}
&html<</body>
</html>>
Quit $$$OK
}
ClassMethod RetrieveAPIInfo(api As %String)
{
w "<h3>Data from <span style='color:red;'>"_api_"</span></h3><p>"
try {
set tHttpRequest=##class(%Net.HttpRequest).%New()
$$$THROWONERROR(sc,##class(%SYS.OAuth2.AccessToken).AddAccessToken(tHttpRequest,"query","GOOGLE",..#OAUTH2APPNAME))
$$$THROWONERROR(sc,tHttpRequest.Get(..#OAUTH2ROOT_api))
set tHttpResponse=tHttpRequest.HttpResponse
s tJSONString=tHttpResponse.Data.Read()
if $e(tJSONString)'="{" {
// not a JSON
d tHttpResponse.OutputToDevice()
} else {
w tJSONString
w "<hr/>"
/*
// new JSON API
&html<<table border=1 style='border-collapse: collapse'>>
s tJSONObject={}.%FromJSON(tJSONString)
set iterator=tJSONObject.%GetIterator()
while iterator.%GetNext(.key,.value) {
if $isobject(value) {
set iterator1=value.%GetIterator()
w "<tr><td>",key,"</td><td><table border=1 style='border-collapse: collapse'>"
while iterator1.%GetNext(.key1,.value1) {
if $isobject(value1) {
set iterator2=value1.%GetIterator()
w "<tr><td>",key1,"</td><td><table border=0 style='border-collapse: collapse'>"
while iterator2.%GetNext(.key2,.value2) {
write !, "<tr><td>",key2, "</td><td>",value2,"</td></tr>"
}
// this way we can go on and on into the embedded objects/arrays
w "</table></td></tr>"
} else {
write !, "<tr><td>",key1, "</td><td>",value1,"</td></tr>"
}
}
w "</table></td></tr>"
} else {
write !, "<tr><td>",key, "</td><td>",value,"</td></tr>"
}
}
&html<</table><hr/>
>
*/
}
} catch (e) {
w "<h3><span style='color: red;'>ERROR: ",$zcvt(e.DisplayString(),"O","HTML")_"</span></h3>"
}
}
}
Vamos dar uma olhada no código:
1. Antes de tudo, precisamos verificar se temos um token de acesso válido (para verificarmos se fomos autorizados)
2. Caso afirmativo, podemos enviar solicitações às APIs oferecidas pelo Google usando o token de acesso emitido
3. Para isso, usamos a classe padrão %Net.HttpRequest, mas adicionamos o token de acesso ao método GET ou POST de acordo com a especificação da API chamada
4. Como é possível ver, o framework OAUTH implementou o método GetUserInfo() para sua comodidade, mas você pode obter as informações do usuário diretamente usando a especificação da API do Google da mesma maneira como feito no método auxiliar RetrieveAPIInfo()
5. Como é comum no mundo do OAUTH trocar dados no formato JSON, apenas lemos os dados recebidos e os colocamos no navegador. Cabe ao desenvolvedor da aplicação analisar e formatar os dados recebidos para apresentá-los ao usuário de alguma forma que faça sentido. Mas isso está além do escopo desta demonstração. (Embora tenhamos colocado um código comentado que mostra como a análise pode ser feita.)
Veja abaixo uma captura de tela da saída exibindo os dados JSON não tratados.

Prossiga para a [parte 2](https://community.intersystems.com/post/cach%C3%A9-open-authorization-framework-oauth-20-implementation-part-2), que descreve como a InterSystems IRIS atua como servidor de autorização e provedor do OpenID Connect.
[1] https://tools.ietf.org/html/rfc6749, https://tools.ietf.org/html/rfc6750
Anúncio
Angelo Bruno Braga · Nov. 9, 2020
Junte-se à nós para mais um Webcast da InterSystems Brasil, desta vez em parceria com a Confluence Informática com o tema "Solução para Monitoramento e Auditoria de Integrações", que será realizado no dia 12 de novembro às 11h (Horário de Brasília).
Inscreva-se, as vagas são limitadas
Artigo
Vinicius Maranhao Ribeiro de Castro · Dez. 21, 2020
Nesta série de artigos de três partes, é mostrado como você pode usar o IAM para simplesmente adicionar segurança, de acordo com os padrões do OAuth 2.0, a um serviço não autenticado anteriormente implantado no IRIS.
Na [primeira parte](https://pt.community.intersystems.com/post/protegendo-suas-apis-com-oauth-20-no-intersystems-api-management-parte-1), foram fornecidos alguns conhecimentos sobre o OAuth 2.0, juntamente com algumas definições e configurações iniciais do IRIS e IAM, para facilitar a compreensão de todo o processo de proteção dos seus serviços.
Esta parte, agora, discutirá e mostrará em detalhes as etapas necessárias para configurar o IAM para validar o token de acesso presente na solicitação de entrada e encaminhar a solicitação para o back-end se a validação for bem-sucedida.
A [última parte](https://pt.community.intersystems.com/post/protegendo-suas-apis-com-oauth-20-no-intersystems-api-management-parte-3) desta série discutirá e demonstrará as configurações necessárias para o IAM gerar um token de acesso (atuando como um servidor de autorização) e validá-lo, junto com algumas considerações finais importantes.
Se você quiser testar o IAM, entre em contato com seu representante de vendas InterSystems.
Cenário 1: IAM como um validador de token de acesso
Neste cenário, será usado um servidor de autorização externo que gera um token de acesso em formato JWT (JSON Web Token). Este JWT é assinado usando o algoritmo RS256 junto com uma chave privada. Para verificar a assinatura do JWT, a outra parte (neste caso, o IAM) precisa ter a chave pública, fornecida pelo servidor de autorização.
Este JWT gerado pelo servidor de autorização externo também inclui, em seu corpo, uma declaração chamada “exp” contendo o carimbo de data/hora (timestamp) de quando esse token expirará, e outra declaração chamada “iss” contendo o endereço do servidor de autorização.
Portanto, o IAM precisa verificar a assinatura do JWT com a chave pública do servidor de autorização e o carimbo de data/hora de expiração contido na declaração "exp" dentro do JWT antes de encaminhar a solicitação ao IRIS.
Para configurar isso no IAM, vamos começar adicionando um plugin chamado “JWT” ao nosso “SampleIRISService” no IAM. Para isso, acesse a página Services do IAM e copie o id do “SampleIRISService”, que usaremos posteriormente.
Depois disso, vá em Plugins, clique no botão “New Plugin”, localize o plugin “JWT” e clique em Enable.
Na página seguinte, cole o id do “SampleIRISService” no campo “service\_id” e selecione a caixa “exp” no parâmetro “config.claims\_to_verify”.
Observe que o valor do parâmetro “config.key\_claim\_name” é “iss”. Vamos usar isso mais tarde.
Em seguida, clique no botão “Create”.
Feito isso, vá até a seção “Consumers” no menu à esquerda e clique em nosso “ClientApp” criado anteriormente. Acesse a aba “Credentials” e clique no botão “New JWT Credential”.
Na página seguinte, selecione o algoritmo usado para assinar o JWT (neste caso RS256) e cole a chave pública no campo “rsa\_public\_key” (esta é a chave pública fornecida a você pelo servidor de autorização em formato PEM).
No campo “key”, você precisa inserir o conteúdo da declaração JWT que você inseriu no campo “config.key\_claim\_name” ao adicionar o plugin JWT. Portanto, neste caso, preciso inserir o conteúdo da declaração iss do meu JWT, que, no meu caso, é o endereço do servidor de autorização.
Em seguida, clique no botão “Create”.
Dica: para fins de depuração, existe uma ferramenta on-line de decodificação de JWT que você pode usar para verificar as declarações e seus valores e verificar a assinatura colando a chave pública. Aqui está o link desta ferramenta on-line: https://jwt.io/#debugger
Agora, com o plugin JWT adicionado, não é mais possível enviar a solicitação sem uma autenticação. Como você pode ver abaixo, em uma simples solicitação GET, sem autenticação, para a URL
**http://iamhost:8000/event/1**
retorna uma mensagem não autorizada juntamente com o código de status “401 Não autorizado”.
Para obter os resultados do IRIS, precisamos adicionar o JWT à solicitação.
Portanto, primeiro precisamos solicitar o JWT ao servidor de autorização. O servidor de autorização personalizado que estamos usando aqui retorna um JWT se uma solicitação POST for feita junto com alguns pares de valores-chave no corpo, incluindo informações de usuário e cliente, para a seguinte URL:
**https://authorizationserver:5001/auth**
Isto é como se parece essa solicitação e a sua resposta:
Em seguida, você pode adicionar o JWT obtido na resposta abaixo no cabeçalho de autorização como um Bearer Token e enviar uma solicitação GET para a mesma URL usada anteriormente:
**http://iamhost:8000/event/1**
Ou você também pode adicioná-lo como um parâmetro de querystring, com a chave de querystring sendo o valor especificado no campo “config.uri\_param\_names” ao adicionar o plugin JWT que, neste caso, é “jwt”:
Finalmente, existe também a opção de incluir JWT na solicitação como um cookie, se algum nome for inserido no campo “config.cookie_names”.
Continue lendo até a terceira e última parte desta série para entender as configurações necessárias para o IAM gerar um token de acesso e validá-lo, junto com algumas considerações finais importantes.
Anúncio
Benjamin De Boe · Abr. 8, 2021
A versão 2020.4 do InterSystems IRIS, IRIS for Health e IRIS Studio já se encontram disponíveis para uso geral.
A plataforma de dados InterSystems IRIS 2020.4 torna inda mais fácil desenvolver, implantar e gerenciar akes it even easier to develop, deploy and manage aplicações de ponta e processos de negócio que unem dados e silos de aplicações. Ela possui várias novas funcionalidades, incluindo:
Melhorias para desenvolvedores de aplicações e interfaces, incluindo:
Suporte ao Java SE 11 LTS, tanto usando o Oracle OpenJDK quanto o AdoptOpenJDK
Suporte a Pooling de Conexão para JDBC
Uma nova ação "foreach" nas regras de roteamento para documentos virtuais segmentados
Melhorias para administradores de bases de dados e sistemas, incluindo:
O ICM agora suporta a implantação do SAM (System Alerting and Monitoring) e do IAM (InterSystems API Manager)
Extensões para nossa sintaxe SQL para tarefas comuns de administração
Implantação simplificada do InterSystems Reports
O InterSystems IRIS for Health 2020.4 contém todas as melhorias acima do InterSystems IRIS 2020.4 e, ainda:
Suporte Aprimorado ao FHIR, incluindo suporte a perfís FHIR.
Suporte ao perfil IHE RMD.
Suporte ao DataGate nas Ferramentas de Migração HL7
Maiores detalhes sobre estas funcionalidades podem ser encontradas na documentação do produto:
Documentação e notas da versão para o InterSystems IRIS 2020.4
Documentação e notas da versão para o InterSystems IRIS for Health 2020.4
Como esta é uma versão CD (Continuous Delivery), está disponível apenas como OCI (Open Container Initiative) também conhecido como formato em contêiner Docker. As imagens de contêiners são disponibilizadas para mecanismos de tempo de execução compatíveis com OCI para as plataformas Linux x86-64 e Linux ARM64, conforme detalhado em documento de Plataformas Suportadas.
As imagens de contêineres para a Edição Enterprise e todos os componentes correspondentes estão disponíveis a partir do InterSystems Container Registry utilizando os seguintes comandos:
docker pull containers.intersystems.com/intersystems/iris:2020.4.0.547.0
docker pull containers.intersystems.com/intersystems/irishealth:2020.4.0.547.0
Para uma lista completa das imagens disponíveis, verifiquem por favor a documentação do ICR (InterSystems Container Registry).
Imagens de contêineres para a Edição Edição Community também podem ser obtidas a partir do Docker store através do uso dos seguintes comandos:
docker pull store/intersystems/iris-community:2020.4.0.547.0
docker pull store/intersystems/iris-community-arm64:2020.4.0.547.0
docker pull store/intersystems/irishealth-community:2020.4.0.547.0
docker pull store/intersystems/irishealth-community-arm64:2020.4.0.547.0
De forma alternativa, versões tarball de todas as imagens de todos os contêineres são disponibilizadas através da página de download de versões CD do WRC.
Nossas listagens correspondentes nos principais marketplaces na nuvem serão atualizadas nos próximos dias.
InterSystems IRIS Studio 2020.4 é um ambiente de desenvolvimento integrado (IDE) para utilização no Windows da Microsoft e pode ser baixado através da página de download de componentes do WRC. Ele funciona com a versão 2020.4 e versões anteriores do InterSystems IRIS e IRIS for Health. A InterSystems também suporta o plugin de VSCode para ObjectScript para desenvolvimento de aplicações para o InterSystems IRIS utilizando-se o Visual Studio Code, que está disponível para Microsoft Windows, Linux and MacOS.
Outros componentes da plataforma InterSystems IRIS 2020.4, como o driver ODBC e o Gateway Web também estão disponíveis na página de download de componentes do WRC.
Anúncio
Angelo Bruno Braga · Maio 20, 2021
Olá Desenvolvedores,
O período de registro para o Concurso de Programação Acelerador FHIR da InterSystems está em pleno andamento! Nós convidamos todos os desenvolvedores FHIR para criar uma aplicação nova ou testar aplicações existentes utilizando o InterSystems IRIS FHIR Accelerator Service (FHIRaaS) on AWS.
E agora você tem uma grande oportunidade para ganhar um acesso GRÁTIS ao FHIRaaS na AWS! Então, para dar o primeiro passo para dominar o FHIRaaS, você precisa se registrar em nosso Portal FHIR Portal utilizando este link:
👉🏼 https://portal.trial.isccloud.io/account/signup
Clique no link acima para se tornar um mestre do FHIRaaS com a InterSystems! ✌🏼
Fiquem a vontade para colocarem suas dúvidas sobre a competição aqui ou no canal discord-concursos.
Boa codificaçãoi!
Artigo
Fernando Ferreira · Mar. 3, 2022
Continuação:Migrando para InterSystems IRIS – Parte 02 – Trocando de sistema operacional e de hardware.
Olá, comunidade! Nesta continuação da segunda parte do artigo vamos apresentar dicas do processo de migração do InterSystems Caché e ou Ensemble para IRIS com um desafio um pouco maior, pois agora vamos trocar de máquina e sistema operacional.
Como comentado na 1ª parte do artigo, a ideia é passar dicas e não substituir os documentos oficiais que estão disponíveis no WRC, que são eles:
InterSystems IRIS Adoption Guide;
How to migrate to InterSystems IRIS.
Cenário atual:
O ambiente está rodando em uma máquina que não possui mais garantia do fabricante e o sistema operacional atual é o um RedHat 6 com uma instância de Ensemble 2018.1.5. O desafio é migrar para InterSystems IRIS 2021.1 para um novo hardware com o RedHat 8.
Como parte do processo de migração, você já verificou os pré-requisitos das plataformas suportadas para a plataforma InterSystems IRIS, de qualquer forma vou deixar o link aqui para que você possa consultar novamente:
https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ISP_technologies#ISP_platforms_server
Sistema operacional:
Ensemble:
A aplicação que roda nesta instância possui um único namespace com dois bancos de dados, sendo:
Database para globais;
Database para rotinas.
Aqui vai a primeira dica, é recomendado que a base das suas rotinas e globais sejam segregadas. Para ambientes onde rotinas e globais convivem no mesmo banco de dados é demando procedimentos adicionais que serão tratados nos próximos artigos.
Uma observação (sempre vale a pena lembrar) para o cenário atual, a migração aqui apresentada é válida para as plataformas InterSystems Caché e Ensemble, o que difere nos procedimentos é que para Ensemble possuem as etapas da Produção, e todas as dicas aqui mencionadas são baseadas na documentação oficial da InterSystems que vocês podem fazer o download no WRC.
Instalação corrente do Ensemble:
Namespace com bancos segregados:
Estrutura no SO:
Dados:
Rotinas:
Agora que já conhecemos o cenário atual, vamos para primeira etapa do processo de migração:
BACKUP / BACKUP / BACKUP / BACKUP / BACKUP / BACKUP / BACKUP / BACKUP / BACKUP
E realizar o procedimento em:
AMBIENTE DE TESTE / AMBIENTE DE TESTE / AMBIENTE DE TESTE / AMBIENTE DE TESTE
Pronto backup realizado, vamos para a etapa seguinte:
Vamos desligar a produção:
Uma dica importante: caso você possua mais de uma produção, lembre-se que você pode para todas as produções via terminal:
Agora vamos parar o Ensemble ou Caché com segurança:
Lembre-se de passar o nome da instância, e no nosso exemplo a instância se chama:
PRODENSEMBLE
Importante verificar o ccconsole.log se não ocorreu nenhum problema durante o shutdown:
Antes de continuar os próximos passos, vamos aqui para algumas dicas, mediante questionamentos que já obtivemos de alguns clientes.
Um dos principais questionamentos:
“Preciso mesmo fazer uma parada total do ambiente para copiar os dados para o novo servidor? Não possa executar o utilitário de backup do InterSystems Caché e ou Ensemble?”
Tenho duas respostas para esse questionamento:
Neste caso depende de como sua aplicação está escrita, pois não se faz necessário para o ambiente todo, e sim o banco que será copiado, ou seja, o banco que será copiado precisa estar desmontado.
Não é possível utilizar o procedimento de backup no InterSystems Caché e ou Ensemble e restaurar no InterSystems IRIS, se faz a necessidade uma cópia fria do banco.
Neste caso vamos exemplificar o banco desmontado:
Agora que executamos a parada total do ambiente ou o banco está desmontado, se faz necessário copiar o CACHE.dat para o novo servidor.
Novo ambiente:
Temos como premissa que a nova instância do InterSystems IRIS já se encontra instalado na nova máquina.
Caso tenha alguma dúvida no procedimento de instalação do IRIS, você pode consultar nossa documentação no seguinte link:
https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GCI
Vamos confirmar alguns dados do novo ambiente:
Sistema operacional:
Instalação do IRIS:
Aqui você pode perceber algumas diferenças:
Nome da nova instância: PRODIRIS
Diretório de instalação: /opt/iris
Portas defaults (Webserver): (SuperServer port = 1972, WebServer = 52773)
Vamos verificar a instalação da nova instância agora:
É possível observar que só existem os namespaces defaults da instalação.
Para banco de dados a mesma situação, somente os bancos defaults da nova instalação.
Agora que já verificamos que o ambiente o novo ambiente está operacional, vamos para as etapas de trazer os dados e as aplicações do ambiente anterior:
Como primeira etapa da migração dos dados, precisamos relembrar uma dica da primeira parte do artigo: verificar a tabela de Endiannes. Se ainda possui alguma dúvida passa lá na primeira parte do artigo:
https://pt.community.intersystems.com/post/migrando-para-o-intersystems-iris-parte-1
Agora precisamos renomear o nome dos bancos, com é citado no guia: InterSystems IRIS Adoption Guide, existe um capítulo com o nome: Different Names. Onde é possível ver com detalhes as diferenças de nomes do ambiente InterSystems Caché e ou Ensemble para o Intersystems IRIS, com exemplo:
Vamos verificar a estrutura dos arquivos pós a cópia:
Agora com os nomes renomeados:
Com os nomes renomeados vamos criar o banco de dados dentro do Portal:
Quando selecionado o caminho com o banco de dados copiado, o IRIS identificará que o banco já existe.
Com os bancos de dados criados, agora é possível criar o namespace apontando para os bancos:
Com os bancos criados e namespace criados, antes de ir para o próximo passo, fica como dica verificar a integridade do banco de dados.
Após a execução verifique o Log de integridade:
Nesta etapa para o cenário que existam páginas CSP, elas precisam ser copiadas também para a nova estrutura e criar o aplicativo no portal:
Com tudo copiado, vamos compilar as Rotinas, Classes e CSP, mesmo procedimento executado na sessão deste artigo:
https://pt.community.intersystems.com/node/511436
Com tudo compilado, podemos verificar os dados via SQL ou Globais
Agora é testar a aplicação e a produção:
Obrigado por acompanhar este artigo e até a próxima parte que o tema será:
Migrando uma instância com Mirror/Shadow de Caché/Ensemble para IRIS
Anúncio
Rochael Ribeiro · Mar. 7, 2022
Três novos conjuntos de lançamentos de manutenção estão agora disponíveis::
Caché 2018.1.6, Ensemble 2018.1.6 e HSAP 2018.1.6
InterSystems IRIS 2020.1.2, IRIS for Health 2020.1.2 e HealthShare Health Connect 2020.1.2
InterSystems IRIS 2021.1.1, IRIS for Health 2021.1.1 e HealthShare Health Connect 2021.1.1
Os kits de instalação e contêineres podem ser baixados do site de Distribuição de Soluções do WRC. As imagens de contêineres para as Edições Enterprise do InterSystems IRIS e do IRIS for Health, assim como todos os componentes correspondentes estão disponíveis a partir do InterSystems Container Registry.
Estas são versões de manutenção com várias atualizações em várias partes dos produtos. Para informações sobre as correções contidas nestas versões, verifique a documentação da versão, que inclui as Notas da Versão, o Checklist para Atualização, uma lista de Alterações da Versão, assim como a Referência de Classes e um conjunto completo de guias , referências, tutoriais e artigos. Toda a documentação pode ser acessada através de docs.intersystems.com.
Os identificadores das versões estão na tabela abaixo:
Versão
Produto
Identificador
2018.1.6
Caché e Ensemble
2018.1.6.717.0
2018.1.6
Avaliação do Caché
2018.1.6.717.0su
2018.1.6
HealthShare Health Connect (HSAP)
2018.1.6HS.9063.0
2020.1.2
InterSystems IRIS
2020.1.2.517.0
2020.1.2
IRIS for Health
2020.1.2.517.0
2020.1.2
HealthShare Health Connect
2020.1.2.517.0
2020.1.2
IRIS Studio
2021.1.2.517.0
2021.1.1
InterSystems IRIS
2021.1.1.324.0
2021.1.1
IRIS for Health
2021.1.1.324.0
2021.1.1
HealthShare Health Connect
2021.1.1.324.0
2021.1.1
IRIS Studio
2021.1.1.324.0
As imagens de contêineres do InterSystems IRIS e IRIS for Health, assim como todos os componentes correspondentes estão disponíveis a partir do InterSystems Container Registry utilizando os seguintes comandos para a versão 2020.1.2:
docker pull containers.intersystems.com/intersystems/iris:2020.1.2.517.0
docker pull containers.intersystems.com/intersystems/irishealth:2020.1.2.517.0
docker pull containers.intersystems.com/intersystems/iris-arm64:2020.1.2.517.0
docker pull containers.intersystems.com/intersystems/irishealth-arm64:2020.1.2.517.0
Para imagens dos contêineres para a versão 2021.1.1:
docker pull containers.intersystems.com/intersystems/iris:2021.1.1.324.0
docker pull containers.intersystems.com/intersystems/irishealth:2021.1.1.324.0
docker pull containers.intersystems.com/intersystems/iris-arm64:2021.1.1.324.0
docker pull containers.intersystems.com/intersystems/irishealth-arm64:2021.1.1.324.0
Para uma lista completa das imagens disponíveis verifique a documentação do ICR.
Anúncio
Angelo Bruno Braga · Jul. 5, 2021
Olá Desenvolvedores,
Temos ótimas novidades para vocês :
💥 Participantes do Concurso de Inteligência Artificial InterSystems podem utilizar Python Incorporado em suas soluções! Ou seja, se você ainda não é membro do Programa de Acesso Antecipado ao Python Incorporado InterSystems (EAP), agora é a hora!
Solicite a adesão em python-interest@intersystems.com e você ganhará acesso GRÁTIS às funcionalidades do Python Incorporado da plataforma de dados InterSystems IRIS.
Além disso, nós convidamos todos os participantes do Programa de Acesso Antecipado para o Webinar Especial de Lançamento do Python Incorporado que irá ocorrer amanhã, dia 6 de Julho às 11:00 horário de brasília – uma forma fácil de começar a entender como utilizar o Python Incorporado! Também serão apresentados no webinar: Uma demonstração das novas funcionalidades da plataforma de dados, aplicações de exemplo e, é claro, as recompensas.
Depois de se tornar um membro do Programa de Acesso Antecipado (EAP), você irá receber um link especial para se juntar ao webinar de lançamento:
➡️ RSVP: python-interest@intersystems.com
Então,
Agora qualquer desenvolvedor Python pode facilmente se juntar ao Concurso de Inteligência Artificial InterSystems em andamento !
Duração: de 28 de Junho a 28 de Julho de 2021
Premiação Total: US$8.750 ,00
Não perca esta oportunidade!
Anúncio
Angelo Bruno Braga · Out. 13, 2022
Olá Comunidade,
Neste vídeo, você aprenderá sobre os novos recursos do InterSystems Healthshare Clinical Viewer e o que está por vir:
⏯ Clinical Viewer & Aplicação de Navegação Clínica: Novidades & O que vem por aí@ Global Summit 2022
🗣 Apresentador: @Julie.Smith, Gerente de Produtos Clinico, InterSystems
Fique ligado para mais vídeos no canal de Desenvolverdores InterSystems no YouTube!