Pesquisar

Olá Comunidade, Recentemente anunciamos os Ganhadores do 1º Concurso de Artigos Técnicos em Português da InterSystems ! Estamos agora planejando a oportunidade para que vocês possam conhecer ao vivo nossos ganhadores e a inspiração, a experiência e os desafios que eles encontraram para escrever seus artigos incríveis !!! Nossos Convidados: @Renan Santos , CEO na isNew Tech @Henry Pereira , Analista de Sistemas na BPlus Tecnologia @Yuri Marx , Arquiteto de Software na YM Services O evento irá ocorrer no dia 05 de Maio às 13:00. Reserve já sua agenda !

Bem-vindo ao capítulo seguinte da [minha série sobre CI/CD](https://pt.community.intersystems.com/post/entrega-contínua-de-sua-solução-intersystems-usando-gitlab-–-índice), onde discuto possíveis abordagens de desenvolvimento de software com tecnologias da InterSystems e GitLab. Hoje, vamos falar sobre interoperabilidade. # Problema Em uma produção de interoperabilidade ativa, há dois fluxos de processo separados: uma produção em funcionamento que processa as mensagens e um fluxo de processo CI/CD que atualiza o código, a configuração da produção e as [configurações padrão do sistema](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ECONFIG_other_default_settings). Claramente, os processos CI/CD afetam a interoperabilidade. No entanto, as perguntas são: - O que acontece exatamente durante uma atualização? - O que precisamos fazer para minimizar ou eliminar o tempo de inatividade da produção durante uma atualização? # Terminologia - Host de Negócio (Business Host - BH) - um elemento configurável da Produção da Interoperabilidade: Serviço de Negócio (Business Service - BS), Processo de Negócio ( Business Process - BP, BPL) ou Operação de Negócio (Business Operation, BO). - Job do Host de Negócio (Business Host Job) - job do InterSystems IRIS que executa o código do Host de Negócio e é gerenciado pela produção de interoperabilidade. - Produção - coleção interconectada de Hosts de Negócio. - Configurações Padrão do Sistema (System Default Settings - SDS) - valores específicos do ambiente de instalação do InterSystems IRIS. - Mensagem Ativa - uma solicitação que está sendo processada por um Job do Host de Negócio. Um Job do Host de Negócio só pode ter uma Mensagem Ativa. O Job do Host de Negócio que não tem uma Mensagem Ativa está inativo. # O que está acontecendo? Vamos começar com o ciclo de vida da produção. ## Início da Produção Primeiro, a Produção pode ser iniciada. Só pode ser executada uma produção por namespace ao mesmo tempo, e em geral (a menos que você saiba o que e porque está fazendo isso), apenas uma produção deve ser executada por namespace. Alternar várias vezes em um namespace entre duas ou mais produções diferentes não é recomendado. Ao iniciar a produção, todos os Hosts de Negócio habilitados definidos nela são inicializados. Se alguns Hosts de Negócio não inicializarem, isso não afeta a inicialização da Produção. Dicas: - Comece a produção no Portal de Gerenciamento de Sistemas ou ao chamar: `##class(Ens.Director).StartProduction("ProductionName")` - Execute código arbitrário na inicialização da Produção (antes que qualquer Job do Host de Negócio seja inicializado) ao implementar um método `OnStart` - A inicialização da Produção é um evento auditável. Você sempre pode ver quem e quando fez o que no Log de Auditoria. ## Atualização da Produção Após a inicialização da Produção, [Ens.Director](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Director) monitora continuamente a produção em execução. Há dois estados de produção: o _estado desejado_, definido na classe da produção e nas Configurações Padrão do Sistema, e o _estado em execução_, os jobs atualmente em execução com configurações aplicadas quando os jobs foram criados. Se os estados desejado e atual forem idênticos, está tudo bem, mas a produção pode (e deve) ser atualizada se houver uma diferença. Geramente, você vê isso como um botão vermelho `Update` na página de Configurações da Produção no Portal de Gerenciamento de Sistemas. A atualização da produção significa uma tentativa de corresponder o estado atual da Produção ao estado visado. A execução de `##class(Ens.Director).UpdateProduction(timeout=10, force=0)` para atualizar a produção faz o seguinte com cada Host de Negócio: 1. Compara as configurações ativas às configurações de produção/SDS/classe 2. Se, e apenas se, (1) apresentar uma discrepância, o Host de Negócio será marcado como desatualizado, exigindo uma atualização. Depois de executar isso para cada Host de Negócio, `UpdateProduction` cria o conjunto de mudanças: - Hosts de Negócio para interromper - Hosts de Negócio para inicializar - Configurações da produção para atualizar E, depois disso, aplica essas mudanças. Dessa forma, "atualizar" as configurações sem mudar nada resulta em nenhum tempo de inatividade da produção. Dicas: - Atualize a produção no Portal de Gerenciamento de Sistemas ou ao chamar: `##class(Ens.Director).UpdateProduction(timeout=10, force=0)` - O tempo limite de atualização padrão do Portal de Gerenciamento de Sistemas é 10 segundos. Se você sabe que o processamento das mensagens leva mais do que isso, chame `Ens.Director:UpdateProduction` com um tempo limite maior. - O tempo limite da atualização é uma configuração da produção, e você pode mudar para um valor maior. Essa configuração se aplica ao Portal de Gerenciamento de Sistemas. ## Atualização do código `UpdateProduction` NÃO ATUALIZA BHs com código desatualizado. Esse é um comportamento voltado para a segurança, mas, se você quiser atualizar todos os BHs em execução automaticamente se o código subjacente mudar, siga estas etapas: Primeiro, carregue e compile desta maneira: ```objectscript do $system.OBJ.LoadDir(dir, "", .err, 1, .load) do $system.OBJ.CompileList(load, "curk", .errCompile, .listCompiled) ``` Agora, `listCompiled` teria todos os itens que foram realmente compilados (use [git diffs](https://github.com/intersystems-ru/GitLab/blob/master/isc/git/Diff.cls) para minimizar o conjunto carregado) devido à flag `u`. Use `listCompiled` para obter um $lb de todas as classes que foram compiladas: ```objectscript set classList = "" set class = $o(listCompiled("")) while class'="" { set classList = classList _ $lb($p(class, ".", 1, *-1)) set class=$o(listCompiled(class)) } ``` Depois disso, calcule uma lista de BHs que precisam de uma reinicialização: ```sql SELECT %DLIST(Name) bhList FROM Ens_Config.Item WHERE 1=1 AND Enabled = 1 AND Production = :production AND ClassName %INLIST :classList ``` Por fim, após obter `bhList`, interrompa e inicie os hosts afetados: ```objectscript for stop = 1, 0 { for i=1:1:$ll(bhList) { set host = $lg(bhList, i) set sc = ##class(Ens.Director).TempStopConfigItem(host, stop, 0) } set sc = ##class(Ens.Director).UpdateProduction() } ``` ## Interrupção da produção As produções podem ser interrompidas, ou seja, uma solicitação pode ser enviada para desativar todos os Jobs do Host de Negócio (com segurança, após lidarem com as mensagens ativas, se houver alguma). Dicas: - Interrompa a produção no Portal de Gerenciamento de Sistemas ou ao chamar: `##class(Ens.Director).StopProduction(timeout=10, force=0)` - O tempo limite de interrupção padrão do Portal de Gerenciamento de Sistemas é 120 segundos. Se você sabe que o processamento das mensagens leva mais do que isso, chame `Ens.Director:StopProduction` com um tempo limite maior. - O tempo limite de interrupção é uma configuração da produção. Você pode alterar isso para um valor maior. Essa configuração se aplica ao Portal de Gerenciamento de Sistemas. - Execute código arbitrário na interrupção da produção ao implementar um método `OnStart` - A interrupção da produção é um evento auditável. Você sempre pode ver quem e quando fez o que no Log de Auditoria. O importante aqui é que a produção seja a soma total dos Hosts de Negócio: - Ao iniciar a produção, todos os Hosts de Negócio habilitados são inicializados. - A interrupção da produção também interrompe todos os Hosts de Negócio em execução. - A atualização da produção significa calcular um subconjunto de Hosts de Negócio que estão desatualizados, para que sejam interrompidos e, imediatamente depois disso, inicializados novamente. Além disso, um Host de Negócio recém-adicionado é inicializado, e um Host de Negócio excluído da produção é interrompido. Isso nos leva ao ciclo de vida dos Hosts de Negócio. ## Inicialização do Host de Negócio Os Hosts de Negócio são compostos de Jobs de Hosts de Negócio idênticos (de acordo com um valor de configuração de tamanho do pool). Ao inicializar um Host de Negócio, todos os Jobs de Hosts de Negócio também são inicializados. Eles são inicializados em paralelo. Jobs de Host de Negócio individuais são inicializados desta maneira: 1. A interoperabilidade define como job um novo processo que se tornaria um Job de Host de Negócio. 2. O novo processo é registrado como um job de interoperabilidade. 3. O código de Host de Negócio e o código do Adapter são carregados na memória do processo. 4. As configurações relacionadas a um Host de Negócio e Adapter são carregadas na memória. A ordem de precedência é: a. Configurações da Produção (substituem as Configurações de Classe e Padrão do Sistema). b. Configurações Padrão do Sistema (substituem as Configurações de Classe). c. Configurações de classe. 5. O job está pronto e começa a aceitar mensagens. Após a conclusão de (4), o Job não pode alterar as configurações ou o código, então quando você importa código novo/igual e configurações padrão do sistema novas/iguais, isso não afeta os jobs de interoperabilidade atualmente em execução. ## Interrupção do Hosts de Negócio Interromper um Job de Host de Negócio significa o seguinte: 1. A interoperabilidade pede que o Job pare de aceitar mensagens/entradas. 2. Se houver uma mensagem ativa, o Job de Host de Negócio tem segundos de tempo limite para processar (ao concluir, finalizando o método `OnMessage` para BO, `OnProcessInput` para BS, `S` para BPL BPs e `On*` para BPs). 3. Se uma mensagem ativa não for processada até o tempo limite e `force=0`, ocorrerá a falha da atualização da produção para esse Host de Negócio (voce verá um botão "Update" vermelho no Portal de Gerenciamento de Sistemas). 4. A interrupção é bem-sucedida se algo nesta lista for verdadeiro: - Nenhuma mensagem ativa - A mensagem ativa foi processada antes de `timeout` - A mensagem ativa não foi processada antes do tempo limite, MAS `force=1` 5. O job é cancelado com interoperabilidade e é interrompido. ## Atualização do Host de Negócio A atualização do Host de Negócio significa a interrupção de todos os Jobs em execução para o Host de Negócio e a inicialização de novos Jobs. ## Regras de negócios, de roteamento e DTLs Todos os Hosts de Negócio são inicializados imediatamente usando as novas versões das Regras de negócios, de roteamento e DTLs assim que ficarem disponíveis. A reinicialização de um Host de Negócio não é necessária nesse caso. # Atualizações offline Às vezes, no entanto, as atualizações da produção exigem tempo de inatividade de Hosts de Negócio individuais. ## Regras dependem de novo código Considere a situação. Você tem uma Regra de Roteamento X atual que encaminha as mensagens para o Processo de Negócio A ou B com base em critérios arbitrários. Em um novo commit, você adiciona, simultaneamente: - Processo de Negócio C - Uma nova versão da Regra de Roteamento X, que encaminha mensagens para A, B ou C. Nesse caso, você não pode só carregar a regra primeiro e depois atualizar a produção. A regra recém-copilada imediatamente começaria a encaminhar as mensagens para o Processo de Negócio C, que o InterSystems IRIS talvez ainda não tenha compilado ou a interoperabilidade ainda não tenha atualizado para usar. Nesse caso, você precisa desativar o Host de Negócio com uma Regra de Roteamento, atualizar o código, atualizar a produção e ativar o Host de Negócio novamente. Observações: - Se você atualizar uma produção usando um [arquivo de implantação de produção](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=EGDV_deploying), todos os BHs afetados são desativados/ativados automaticamente. - Para hosts invocados InProc, a compilação invalida o cache de um host específico mantido pelo autor da chamada. ## Dependências entre Hosts de Negócio As dependências entre Hosts de Negócio são fundamentais. Suponha que você tenha os Processos de Negócio A e B, em que A envia mensagens a B. Em um novo commit, você adiciona, simultaneamente: - Uma nova versão do Processo A, que define uma nova propriedade X em uma solicitação para B - Uma nova versão do Processo B que pode processar uma nova propriedade X Nesse caso, PRECISAMOS atualizar o Processo B primeiro e o A depois. Você pode fazer isso de uma das seguintes maneiras: - Desativar Hosts de Negócio durante a atualização - Divida a atualização em duas partes: primeiro, atualize apenas o Processo B e, depois, em uma atualização separada, comece a enviar mensagens para ele do Processo A. Uma variação mais desafiadora desse tema, em que as novas versões dos Processos A e B são incompatíveis com as versões antigas, exige tempo de inatividade do Host de Negócio. ## Filas Se você sabe que, após a atualização, um Host de Negócio não conseguirá processar mensagens antigas, você precisa garantir que a Fila do Host de Negócio esteja vazia antes da atualização. Para isso, desative todos os Hosts de Negócio que enviam mensagens para o Host de Negócios e espere até que a fila fique vazia. ## Mudança de estado nos Processos de Negócio BPL Primeiro, uma pequena introdução sobre como funcionam os BPs do BPL. Depois de compilar um BP do BPL, duas classes são criadas no pacote com o mesmo nome que o da classe BPL completa: - A classe `Thread1` contém os métodos S1, S2, ... SN, que corresponde às atividades no BPL - A classe `Context` tem todas as variáveis de contexto, além do próximo estado que o BPL executaria (ou seja, `S5`) Além disso, a classe BPL é persistente e armazena as solicitações que estão sendo processadas. O BPL funciona ao executar os métodos `S` em uma classe `Thread` e atualizando de maneira correspondente a tabela da classe BPL, `Context` e `Thread1`, em que uma mensagem "em processamento" é uma linha em uma tabela BPL. Após o processamento da solicitação, o BPL exclui as entradas do BPL, `Context` e `Thread`. Como os BPs do BPL são assíncronos, um job BPL pode processar simultaneamente várias solicitações ao salvar as informações entre chamadas `S` e alternar entre diferentes solicitações. Por exemplo, o BPL processou uma solicitação até chegar a uma atividade `sync`, aguardando uma resposta da BO. Ele salvaria o contexto atual no disco, com a propriedade `%NextState` (na classe `Thread1`) definida para o método `S` de atividade de resposta e trabalharia em outras solicitações até a BO responder. Após a resposta da BO, o BPL carregaria "Context" na memória e executaria o método correspondente a um estado salvo na propriedade `%NextState`. Agora, o que acontece quando atualizamos o BPL? Primeiro, precisamos conferir se pelo menos uma destas condições é atendida: - Durante a atualização, a tabela Context está vazia, o que significa que nenhuma mensagem ativa está em trabalho. - Os Novos Estados são os mesmos que os antigos ou os novos Estados são adicionados após os antigos. Se pelo menos uma condição for atendida, podemos continuar. Não há solicitações de pré-atualização para processar o BPL pós-atualização ou os Estados são adicionados no final, o que significa que as solicitações antigas também podem ir para lá (supondo que as solicitações de pré-atualização sejam compatíveis com as atividades e o processamento do BPL pós-atualização). Mas e se você tiver solicitações ativas em processamento e o BPL mudar a ordem dos estados? O ideal é, se você puder esperar, desativar os autores de chamada do BPL e esperar até que a fila esteja vazia. Valide se a tabela Context também está vazia. Lembre-se de que a Fila mostra apenas as solicitações não processadas e a tabela Context armazena as solicitações em trabalho, então um BPL muito ocupado pode mostrar o tamanho da Fila como zero e isso é normal. Depois disso, desative o BPL, realize a atualização e ative todos os Hosts de Negócio desativados anteriormente. Se isso não for possível (geralmente quando o BPL é muito longo, lembro de atualizar um que demorou cerca de uma semana para processar uma solicitação, ou a janela de atualização é muito curta), use o [versionamento do BPL](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=EBPLR_process). Como alternativa, você pode escrever um script de atualização. No script de atualização, mapeie os próximos estados antigos para os próximos estados novos e execute na tabela `Thread1` para que o BPL atualizado possa processar solicitações antigas. O BPL precisa ser desativado durante a atualização. Dito isso, é uma situação extremamente rara e geralmente desnecessária, mas, se precisar fazer isso, é dessa maneira. # Conclusão A interoperabilidade implementa um algoritmo sofisticado para minimizar o número de ações necessárias para atualizar a produção após a alteração do código subjacente. Chame UpdateProduction com um tempo limite seguro em cada atualização de SDS. Para cada atualização de código, você precisa decidir uma estratégia. Minimizar a quantidade de código compilado usando [git diffs](https://github.com/intersystems-ru/GitLab/blob/master/isc/git/Diff.cls) ajuda no tempo de compilação, mas "atualizar" o código com ele mesmo e compilá-lo novamente ou "atualizar" as configurações com os mesmos valores não aciona ou exige uma atualização da produção. Atualizar e compilar Regras de Negócio, Regras de Roteamento e DTLs os torna imediatamente acessíveis sem a atualização da produção. Por fim, a atualização da produção é uma operação segura e geralmente não requer tempo de inatividade. # Links - [Ens.Director](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Director) - [Criando git diffs](https://github.com/intersystems-ru/GitLab/blob/master/isc/git/Diff.cls) - [Configurações Padrão do Sistema](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ECONFIG_other_default_settings) O autor gostaria de agradecer a @James.MacKeith, @Dmitry.Zasypkin e @Regilo.Souza pela ajuda inestimável com este artigo.

Após uma pausa de quase quatro anos, [minha série sobre CI/CD](https://pt.community.intersystems.com/post/entrega-contínua-de-sua-solução-intersystems-usando-gitlab-–-índice) está de volta! Ao longo dos anos, trabalhei com vários clientes da InterSystems, desenvolvendo pipelines de CI/CD para diferentes casos de uso. Espero que as informações apresentadas neste artigo sejam úteis para alguém. Esta [série de artigos](https:/pt.community.intersystems.com/post/entrega-contínua-de-sua-solução-intersystems-usando-gitlab-–-índice) discute várias abordagens possíveis para o desenvolvimento de software com tecnologias da InterSystems e do GitLab. Temos uma variedade interessante de tópicos para abordar: hoje, vamos falar sobre elementos fora do código — ou seja, configurações e dados. # Problema Anteriormente, discutimos promoções de código e, de certa forma, sem estado — sempre passamos de uma instância (presumivelmente) vazia para uma codebase completa. No entanto, às vezes, precisamos fornecer dados ou estado. Há diferentes tipos de dados: - Configuração: usuários, web apps, LUTs, esquemas personalizados, tarefas, parceiros de negócios e muito mais - Configurações: pares de chaves-valor específicas ao ambiente - Dados: com frequência, tabelas de referência precisam ser fornecidas para seu app funcionar Vamos discutir todos esses tipos de dados e como eles podem ser adicionados primeiro ao controle de fonte e posteriormente implantados. # Configuração A configuração do sistema é dividida em muitas classes diferentes, mas o InterSystems IRIS pode exportar a maioria delas para XMLs. Primeiro, um [Pacote de segurança](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&PACKAGE=Security) contém informações sobre: - Web Apps - DocDBs - Domínios - Eventos de auditoria - Servidores KMIP - Configurações LDAP - Recursos - Funções - Privilégios SQL - Configurações SSL - Serviços - Usuários Todas essas classes fornecem métodos Exists, Export e Import, permitindo movê-las entre ambientes. Algumas ressalvas: - Os usuários e as configurações de SSL podem conter informações confidenciais, como senhas. Geralmente, NÃO é recomendado armazená-los no controle de fonte por motivos de segurança. Use os métodos Export/Import para facilitar transferências únicas. - Por padrão, os métodos Export/Import geram os resultados em um arquivo, o que talvez não seja compatível com o controle de fonte. Veja uma [classe de utilitário](https://gist.github.com/eduard93/3a9abdb2eb150a456191bf387c1fc0c3) que pode exportar e importar Tabelas Lookup, Esquemas Personalizados, Parceiros de Negócio, Tarefas, Credenciais e Configuração SSL. Ela exporta um item por arquivo, então você obtém um diretório com LUT, outro diretório com esquemas personalizados e assim por diante. Para configurações SSL, ela também exporta arquivos: certificados e chaves. Também vale a pena notar que, em vez de importar/exportar, você pode usar [%Installer](https://community.intersystems.com/post/deploying-applications-intersystems-cache-installer) ou [Mesclagem CPF](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ACMF) para criar a maioria desses elementos. Ambas as ferramentas também são compatíveis com a criação de namespaces e bancos de dados. A Mesclagem CPF pode ajustar as configurações do sistema, como o tamanho do buffer global. ## Tarefas A classe [%SYS.Task](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYS.Task) armazena tarefas e fornece métodos `ExportTasks` e `ImportTasks`. Você também pode verificar a classe de utilitário acima para importar e exportar tarefas uma a uma. Observe que, ao importar tarefas, você pode obter erros de importação (`ERROR #7432: Start Date and Time must be after the current date and time` - A data e o horário de início precisam ser posteriores à data e ao horário atual) se `StartDate` ou outras propriedades relacionadas à programação estiverem no passado. Como solução, defina `LastSchedule` como `0` para o InterSystems IRIS reprogramar uma tarefa recém-importada para ser executada em um futuro próximo. ## Interoperabilidade As produções de interoperabilidade contêm: - Parceiros de negócio - Configurações Padrão do Sistema - Credenciais - Tabelas Lookup Os dois primeiros estão disponíveis no pacote [Ens.Config](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&PACKAGE=Ens.Config) com métodos `%Export` e `%Import`. Exporte Credenciais e Tabelas Lookup usando a [classe de utilitário](https://gist.github.com/eduard93/3a9abdb2eb150a456191bf387c1fc0c3) acima. Em versões recentes, Tabelas Lookup podem ser exportadas/importadas pela classe [$system.OBJ](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ). # Configurações [Configurações Padrão de Sistema](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ECONFIG_other_default_settings#ECONFIG_other_default_settings_purpose) - é um mecanismo de interoperabilidade padrão para configurações específicas ao ambiente: > A finalidade das configurações padrão do sistema é simplificar o processo de cópia de uma definição de produção de um ambiente para outro. Em qualquer produção, os valores de algumas configurações são determinados como parte do design de produção. Geralmente, essas configurações são as mesmas em todos os ambientes. Outras configurações, no entanto, precisam ser ajustadas ao ambiente. Essas configurações incluem caminhos de arquivo, números de portas e assim por diante. > > As configurações padrão do sistema precisam especificar apenas os valores do ambiente em que o InterSystems IRIS está instalado. Por outro lado, a definição da produção precisa especificar valores de configurações que devem ser iguais em todos os ambientes. Recomendo usá-los em ambientes de produção. Use [%Export](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Config.DefaultSettings#%25Export) e [%Import](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Config.DefaultSettings#%25Import) para transferir as configurações padrão do sistema. ## Configurações do aplicativo Seu aplicativo provavelmente também usa configurações. Nesse caso, recomendo usar as Configurações Padrão do Sistema. Embora seja um mecanismo de interoperabilidade, as configurações podem ser acessadas via: `%GetSetting(pProductionName, pItemName, pHostClassName, pTargetType, pSettingName, Output pValue)` ([documentos](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Config.DefaultSettings#%25GetSetting)). Você pode escrever um wrapper para definir os padrões com que você não se importa, por exemplo: ```objectscript ClassMethod GetSetting(name, Output value) As %Boolean [Codemode=expression] { ##class(Ens.Config.DefaultSettings).%GetSetting("myAppName", "default", "default", , name, .value) } ``` Se você quiser mais categorias, você também pode expor argumentos `pItemName` e/ou `pHostClassName`. As configurações podem ser definidas inicialmente ao importar, usar o Portal de Gerenciamento de Sistema, criar objetos da classe `Ens.Config.DefaultSettings` ou definir `^Ens.Config.DefaultSettingsD` como global. Meu principal conselho aqui seria manter as configurações em um só lugar (pode ser as Configurações Padrão do Sistema ou uma solução personalizada), e o aplicativo precisa obter as configurações usando apenas a API fornecida. Dessa forma, o próprio aplicativo não conhece o ambiente e o que resta é fornecer um armazenamento centralizado de configurações com valores específicos ao ambiente. Para isso, crie uma pasta de configurações no seu repositório contendo arquivos de configuração com nomes iguais aos das ramificações do ambiente. Em seguida, durante a fase do CI/CD, use a [variável de ambiente](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html) `$CI_COMMIT_BRANCH` para carregar o arquivo correto. ``` DEV.xml TEST.xml PROD.xml ``` Se você tiver vários arquivos de configurações por ambiente, use pastas com nomes de ramificações de ambiente. Para obter o valor da variável de ambiente de dentro do InterSystems IRIS, [use](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.Util#GetEnviron) `$System.Util.GetEnviron("name")`. # Dados Se você quiser disponibilizar dados (tabelas de referência, catálogos, etc.), há várias formas de fazer isso: - Exportação global. Use uma [exportação GOF](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GGBL_managing#GGBL_managing_export) binária ou uma nova exportação XML. Com a exportação GOF, lembre-se de que os locais nos sistemas de origem e destino precisam corresponder (ou pelo menos a ordenação global precisa estar disponível no sistema de destino). A [exportação XML](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ) ocupa mais espaço. Você pode melhorar isso ao exportar o global para um arquivo `xml.gz`, os métodos `$system.OBJ` automaticamente (des)arquivam os arquivos `xml.gz` conforme necessário. A principal desvantagem dessa abordagem é que os dados não são legíveis por humanos, nem mesmo o XML — a maioria é codificado em base64. - CSV. Faça a [exportação CSV](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SQL.StatementResult#%25DisplayFormatted) e importe com [LOAD DATA](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=RSQL_loaddata). Prefiro o CSV, pois é o formato legível por humanos com armazenamento mais eficiente, que pode ser importado por qualquer coisa. - JSON. Crie uma classe [habilitada para JSON](https://docs.intersystems.com/iris20221/csp/docbook/DocBook.UI.Page.cls?KEY=GJSON_adaptor). - XML. Crie uma classe [habilitada para XML](https://docs.intersystems.com/iris20221/csp/docbook/DocBook.UI.Page.cls?KEY=GXMLPROJ_intro) para projetar objetos no XML. Use se os dados tiverem uma estrutura complexa. O formato que você deve escolher depende do seu caso de uso. Listei aqui os formatos na ordem de eficiência de armazenamento, mas essa não é uma preocupação se você não tiver muitos dados. # Conclusões O estado adiciona complexidade aos seus pipelines de implantação de CI/CD, mas o InterSystems IRIS fornece uma vasta gama de ferramentas para gerenciá-lo. # Links - [Classe de utilitário](https://gist.github.com/eduard93/3a9abdb2eb150a456191bf387c1fc0c3) - [%Installer](https://community.intersystems.com/post/deploying-applications-intersystems-cache-installer) - [Mesclagem CPF](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ACMF) - [$System.OBJ](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ) - [Configurações Padrão do Sistema](https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=ENSLIB&CLASSNAME=Ens.Config.DefaultSettings#%25GetSetting)

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: * Git básico * Fluxo Git (processo de desenvolvimento) * Instalação do GitLab * Fluxo de trabalho do GitLab * Entrega contínua * Instalação e configuração do GitLab * CI/CD do GitLab * **Por que contêineres?** * CI/CD do GitLab usando contêineres No [primeiro artigo](https://pt.community.intersystems.com/post/entrega-cont%C3%ADnua-de-sua-solu%C3%A7%C3%A3o-intersystems-usando-gitlab-%E2%80%93-parte-i-git), abordamos os fundamentos do Git, por que um entendimento de alto nível dos conceitos do Git é importante para o desenvolvimento de software moderno e como o Git pode ser usado para desenvolver software. No [segundo artigo](https://pt.community.intersystems.com/post/entrega-cont%C3%ADnua-de-sua-solu%C3%A7%C3%A3o-intersystems-usando-gitlab-%E2%80%93-parte-ii-fluxo-de-trabalho-do), abordamos o fluxo de trabalho do GitLab: um processo inteiro do ciclo de vida do software e a entrega contínua. No [terceiro artigo](https://pt.community.intersystems.com/post/entrega-cont%C3%ADnua-de-sua-solu%C3%A7%C3%A3o-intersystems-usando-gitlab-%E2%80%93-parte-iii-instala%C3%A7%C3%A3o-e), abordamos a instalação e configuração do GitLab e a conexão dos seus ambientes a ele No [quarto artigo](https://pt.community.intersystems.com/post/entrega-cont%C3%ADnua-de-sua-solu%C3%A7%C3%A3o-intersystems-usando-gitlab-%E2%80%93-parte-iv-configura%C3%A7%C3%A3o-da-cd), escrevemos uma configuração de CD. Neste artigo, falaremos sobre os contêineres e como (e por que) podem ser usados. Este artigo presume a familiaridade com os conceitos de docker e contêiner. Confira estes artigos do @Luca.Ravazzolo se quiser ler sobre [contêineres](https://community.intersystems.com/post/container-what-container) e [imagens](https://community.intersystems.com/post/container-what-container-image). ## Vantagens Há muitas vantagens em usar contêineres: * Portabilidade * Eficiência * Isolamento * Leveza * Imutabilidade Vamos falar sobre cada uma em detalhes. ### Portabilidade Um contêiner embrulha um aplicativo com tudo o que ele precisa para ser executado, como arquivos de configuração e dependências. Isso permite que você execute aplicativos de maneira fácil e confiável em diferentes ambientes, como seu desktop local, servidores físicos, servidores virtuais, testes, staging, ambientes de produção e nuvens públicas ou privadas. Outro ponto da portabilidade é que, depois de criar sua imagem do Docker e verificar que ela é executada corretamente, ela pode ser executada em qualquer outro lugar que execute o docker, que atualmente são os servidores Windows, Linux e MacOS. ### Eficiência Você só precisa que o processo do aplicativo seja executado, e não todo o sistema, etc. E os contêineres oferecem exatamente isso: eles executam apenas os processos de que você precisa explicitamente e nada mais. Como os contêineres não exigem um sistema operacional separado, eles consomem menos recursos. Enquanto uma VM costuma ter vários gigabytes de tamanho, um contêiner geralmente tem apenas algumas centenas de megabytes, tornando possível executar muito mais contêineres do que VMs em um único servidor. Como os contêineres têm um nível de uso mais alto em relação ao hardware subjacente, você precisa de menos hardware, resultando em uma redução nos custos dos servidores bare metal, bem como dos centros de processamento de dados. ### Isolamento Os contêineres isolam seu aplicativo de todo o resto e, embora vários contêineres possam ser executados no mesmo servidor, eles podem ser completamente independentes uns dos outros. Qualquer interação entre contêineres deve ser explicitamente declarada como tal. Se um contêiner falhar, ele não afetará os outros e poderá ser reiniciado rapidamente. A segurança também se beneficia desse isolamento. Por exemplo, explorar a vulnerabilidade do servidor web em um servidor bare metal pode dar a um invasor acesso a todo o servidor, mas, no caso dos contêineres, o invasor só teria acesso ao contêiner do servidor web. ### Leveza Como os contêineres não exigem um sistema operacional separado, eles podem ser iniciados, interrompidos ou reinicializados em questão de segundos, o que acelera todos os pipelines de desenvolvimento relacionados e o tempo de produção. Você pode começar a trabalhar antes e não gastar nenhum tempo na configuração.  ### Imutabilidade A infraestrutura imutável é composta por componentes imutáveis que são substituídos a cada implantação, em vez de serem atualizados no local. Esses componentes são inicializados a partir de uma imagem comum que é criada uma vez por implantação e pode ser testada e validada. A imutabilidade reduz a inconsistência e permite a replicação e a movimentação entre diferentes estados do seu aplicativo com facilidade. Mais sobre a [imutabilidade](https://blog.codeship.com/immutable-infrastructure/). ## Novas possibilidades Todas essas vantagens nos permitem gerenciar a infraestrutura e o fluxo de trabalho de maneiras totalmente novas. ### Orquestração Há um problema com ambientes bare metal ou VM, eles ganham _individualidade_, o que traz várias surpresas depois, geralmente desagradáveis. A resposta para isso é a **infraestrutura como código**, o gerenciamento da infraestrutura em um modelo descritivo, usando as mesmas versões que a equipe de DevOps usa para o código-fonte. Com a infraestrutura como código, um comando de implantação sempre coloca o ambiente de destino na mesma configuração, não importa o estado inicial do ambiente. Isso é alcançado ao configurar automaticamente um destino existente ou descartar o destino existente e recriar um novo ambiente. Assim, com a infraestrutura como código, as equipes fazem alterações na descrição do ambiente e na versão do modelo de configuração, que normalmente está em formatos de código bem documentados, como JSON. O pipeline de lançamento executa o modelo para configurar ambientes de destino. Se a equipe precisar fazer alterações, ela editará a fonte, e não o destino. Tudo isso é possível e muito mais fácil de fazer com contêineres. Leva poucos segundos para desativar um contêiner e iniciar outro, enquanto o provisionamento de uma nova VM leva alguns minutos. E nem estou falando em reverter um servidor para um estado limpo. ### Escalonamento Do ponto anterior, você pode ter uma ideia de que a infraestrutura como código é estática por si só. Não é, pois as ferramentas de orquestração também podem fornecer escalonamento horizontal (provisionando mais do mesmo) com base na carga de trabalho atual. Você só deve executar o que é necessário no momento e escalonar seu aplicativo de acordo. Isso também pode reduzir custos. ## Conclusão Os contêineres podem otimizar seu pipeline de desenvolvimento. A eliminação de inconsistências entre ambientes permite testes e depurações mais fáceis. A orquestração permite que você crie aplicativos escalonáveis.  A implantação ou reversão para qualquer ponto do histórico imutável é possível e fácil. As organizações querem trabalhar em um nível mais alto, onde todos os problemas listados acima já estejam resolvidos e onde encontramos agendadores e orquestradores lidando com mais coisas de maneira automatizada. O que vem a seguir No próximo artigo, vamos falar sobre o provisionamento com contêineres e a criação da configuração de CD que usa o contêiner Docker do InterSystems IRIS.

Olá Desenvolvedores! Aqui estão os bônus de tecnologia para o InterSystems Health FHIR Contest 2022 que darão a você pontos extras na votação: Tópico sobre a saúde da mulher Conjunto de dados de saúde da mulher Uso do IRIS For Health FHIR ou FHIR Cloud Server Interoperabilidade de Saúde Uso do Python Nativo Uso de contêiner Docker Implantação em pacote ZPM Demonstração on-line Passagem de qualidade de código Artigo na Comunidade de Desenvolvedores O segundo artigo na Comunidade de Desenvolvedores Vídeo no YouTube Primeira Vez Vejam os detalhes abaixo: Tópico sobre a saúde da mulher - 5 pontos Ganhe 5 pontos de bônus se sua solução estiver ajudando com qualquer tema relativo a problemas de saúde da mulher. Por exemplo, se seu aplicativo puder ajudar pacientes grávidas a descobrir tendências no rastreamento de sintomas de gravidez e/ou criar uma integração para compartilhar sintomas e anotações do diário de gravidez com um aplicativo de parceiro Conjunto de dados de saúde da mulher - 3 pontos Colete 3 pontos de bônus se você enviar um conjunto de dados de Saúde da Mulher para o Open Exchange e usá-lo em sua inscrição. Aqui estão exemplos de conjuntos de dados no Open Exchange: titanic, community posts, health datasets. O conjunto de dados deve ser um aplicativo Open Exchange separado. Uso do IRIS For Health FHIR ou FHIR Cloud Server - 2 pontos Colete 2 pontos de bônus se sua solução usar o servidor FHIR via IRIS for Health ou InterSystems FHIR Server na AWS. Obtenha o modelo IRIS For Health com o servidor FHIR em execução aqui. Você pode ativar sua instância de servidor FHIR. Interoperabilidade de Saúde - 4 pontos Ganhe 4 pontos de bônus se seu aplicativo for solução de interoperabilidade de saúde que usa a interoperabilidade InterSystems para transferir e/ou transformar dados de saúde por meio de mensagens ou usa transformação de dados em formatos de saúde. aqui está um exemplo de solução dfe interoperabilidade de saúde. Python Nativo - 3 pontos Use o Python Nativo em sua aplicação e acumule 3 pontos extras. Você precisará ao menos da versão do InterSystems IRIS 2021.2 para isso. Uso de contêiner Docker - 2 pontos O aplicativo recebe um bônus de 'contêiner Docker' se usar o InterSystems IRIS em execução em um contêiner docker. Aqui está o exemplo mais simples para se iniciar. Implantação em pacote ZPM - 2 pontos Você pode coletar o bônus se criar e publicar o pacote ZPM (ObjectScript Package Manager) para seu aplicativo Full-Stack para que ele possa ser implantado com o comando: zpm "install your-multi-model-solution" em um IRIS com o cliente ZPM instalado. Cliente ZPM. Documentação. Demonstração on-line de seu projeto - 2 pontosGanhe mais 3 pontos de bônus se publicar seu projeto em nuvem como uma demonstração online. Você pode fazer isso sozinho ou pode usar este modelo - Você encontra aqui um Exemplo. Aqui está o vídeo de como utilizá-lo. Passagem de qualidade de código sem bugs - 1 ponto ​​​​​​​Inclua a ação Github de qualidade de código para controle estático de código e mostre 0 bugs para seu código ObjectScript. Artigo na Comunidade de Desenvolvedores​​​​​​​ - 2 pontos Publique um artigo na Comunidade de Desenvolvedores que descreva os recursos do seu projeto. Colete 2 pontos para cada artigo. Traduções para diferentes idiomas também funcionam. O segundo artigo na Comunidade de Desenvolvedores​​​​​​​ - 1 ponto Você pode coletar mais um ponto de bônus para o segundo artigo ou a tradução do artigo. O 3º e próximos não trarão mais pontos, mas a atenção será toda sua. Vídeo no YouTube - 3 pontos Faça o vídeo do Youtube que demonstra seu produto em ação e ganhe 3 pontos de bônus por cada. Exemplos. Primeira Vez - 3 pontos Acumule 3 pontos de bônus se você participar de concursos InterSystems Open Exchange pela primeira vez! A lista de bônus está sujeita a alterações. Fique ligado! Boa sorte com a competição!

Ei Comunidade, Estamos muito animados para anunciar os vencedores do Concurso InterSystems IRIS for Health: FHIR para a Saúde da Mulher! Obrigado a todos por participarem de nossa competição de codificação. Sem mais delongas, os vencedores são... Nomeação de especialista 🥇 1º lugar e US$5.000 vão para o app FemTech Reminder de @KATSIARYNA.Shaustruk, @Maria.Gladkova, @Maria.Nesterenko 🥈 2º lugar e US3.000 vão para o app Pregnancy Symptoms Tracker de @José.Pereira, @Henrique.GonçalvesDias, @Henry.HamonPereira 🥉 3º lugar e US$1.500 vão para o app Contest-FHIR de @Lucas.Enard2487 🏅 4º lugar e US$750 vão para o app fhir-healthy-pregnancy de @Edmara.Francisco 🏅 5º lugar e US$500 vão para o app iris-fhir-app de @Oliver.Wilms More winners: 🏅 US$100 vão para o app Dia-Bro-App de @Dzmitry.Rabotkin, Maria Muzychuk, Maxim Eliseykin 🏅 US$100 vão para o app NeuraHeart de @Grzegorz.Koperwas 🏅 US$100 vão para o app FHIR Questionnaires de @Yuri.Gomes 🏅 US$100 vão para o app Beat Savior de @Jan.Skála 🏅 US$100 vão para o app ehh2022-diabro de @Maksym.Shcherban 🏅 US$100 vão para o app Dexcom Board de @Daniel.Šulc, Matěj Žídek, Tomáš Dorda Community Nomination 🥇 1º lugar e US$1.000 vão para o app Pregnancy Symptoms Tracker de @José.Pereira, @Henrique.GonçalvesDias, @Henry.HamonPereira 🥈 2º lugar e US$750 vão para o app FemTech Reminder de @KATSIARYNA.Shaustruk, @Maria.Gladkova, @Maria.Nesterenko 🥉 3º lugar e US$500 vão para o app fhir-healthy-pregnancy de @Edmara.Francisco Os nossos mais sinceros parabéns a todos os participantes e vencedores! Junte-se à diversão da próxima vez 😎

Neste artigo, vou tentar explicar a etapa de implantação do IAM no meu EC2(ubuntu). ## O que é o IAM? IAM é o InterSystems API Manager consulte o link abaixo para saber mais sobre o IAM    ## Antes de implantar o IAM ### Confira a licença do host da API .png) .png) ####   ### Ative o IAM do usuário .png) .png)   ## Implante o IAM ### Referência    ### Faça o download da imagem no link a seguir Fiz o download da seguinte versão no meu PC .png)   ### Upload da imagem no EC2 Usei o comando scp para fazer upload da imagem na minha nuvem .png) ###   ### Confira se o docker e o docker compose estão instalados Caso contrário, acesse o link a seguir [ https://docs.docker.com/engine/install/ubuntu/](http://https://docs.docker.com/engine/install/ubuntu/)   ### Descompacte o arquivo tar de imagem tar zpxvf IAM-3.0.2.0-4.tar.gz .png) ###   ### Carregue a imagem no docker sudo docker load -i iam_image.tar .png)   ### Execute o iam-setup.sh source ./iam-setup.sh   .png) .png)   ### Edite o arquivo: docker-compose.yml  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)   ### Inicie o contêiner sudo docker compose up -d ### .png) ###   ### Confira a IU do IAM Acesse a IU do IAM pelo link a seguir http://yourEC2publicAddress:8002/overview .png)      

#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 🙂

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!

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.

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 😉

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.

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

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

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.