Sumário

1. Propósito do artigo
2. O que são containers e por que eles fazem sentido com o IRIS
   1. Containers e Imagens em poucas palavras
   2. Por que containers são úteis para desenvolvedores
   3. Por que o IRIS funciona bem com o Docker
3. Pré-requisitos
4. Instalando a imagem do InterSystems IRIS
   1. Usando o Docker Hub
   2. Puxando a imagem
5. Executando a imagem do InterSystems IRIS
   1. ​​​​​​​Iniciando um container do IRIS
   2. Verificando o status do container
   3. Executando código no terminal do container
   4. Acessando o IRIS Management Portal
   5. Conectando o container ao VS Code
   6. Parando ou removendo o container
   7. Definindo uma senha específica com uma montagem de vínculo (bind mount) 
   8. Usando volumes %SYS duráveis                       
      1. O que é armazenado com o %SYS durável            
      2. Como habilitar o %SYS durável
6. Usando Docker Compose
    6.1 Exemplo de Docker Compose
    6.2 Executando Docker Compose
7. Usando um Dockerfile para executar código-fonte personalizado
   1. Exemplo de Dockerfile
   2. Exemplo de Docker Compose
   3. Entendendo camadas, tagging de imagem e tempo de build vs. tempo de execução
   4. Código-fonte e script de inicialização (init script)
   5. Construindo a imagem com Dockerfile
   6. Executando instruções no terminal IRIS containerizado
8. Conclusão e próximos passos

---

1. Propósito do artigo

A Comunidade de Desenvolvedores da InterSystems já possui muitos artigos excelentes explicando o que é Docker, os comandos mais importantes e vários casos de uso para o InterSystems IRIS em um ambiente containerizado.

O propósito desta série de artigos é um pouco diferente. Como sou um grande fã de guias passo a passo, desejo criar um walkthrough abrangente sobre como configurar e usar o Docker com o InterSystems IRIS, começando pelo muito básico e avançando gradualmente para cenários mais avançados, como instâncias multi-namespace, containers interconectados, integrações com sistemas externos e aplicações que compreendem uma UI (Interface de Usuário).

2. O que são containers e por que eles fazem sentido com o IRIS

2.1 Containers e Imagens em poucas palavras

Tradicionalmente, a execução de uma aplicação exigia que a versão fosse compatível com o seu sistema operacional e que fosse empacotada para aquele destino específico. Ao mesmo tempo, cada aplicação deveria ser empacotada para funcionar especificamente com um sistema de destino. Se você quisesse que uma aplicação rodasse no macOS e no Windows, teria que mudar o design da aplicação e empacotá-la para os diferentes sistemas. As imagens e os containers Docker são tecnologias de deployment de aplicações que resolvem esses problemas, permitindo que os desenvolvedores empacotem o software uma única vez e o executem em qualquer lugar.

Docker é uma plataforma de software que empacota software em containers. Uma imagem Docker, ou imagem de container, é um arquivo autônomo e executável que contém todas as instruções (bibliotecas, dependências e arquivos) para criar e executar um container. Uma imagem Docker é compartilhável e portátil, então você pode implantar a mesma imagem em vários locais ao mesmo tempo. Um container Docker é um ambiente de tempo de execução com todos os componentes necessários para executar o código da aplicação sem usar as dependências da máquina host.

Diferente das máquinas virtuais, os containers são leves. Eles não precisam de um sistema operacional completo e rodam diretamente no sistema operacional host através do Docker Engine, usando apenas os binários e bibliotecas necessários para a aplicação específica, o que os torna mais eficientes. Múltiplos containers isolados podem ser iniciados em paralelo na mesma máquina sem interferir uns nos outros.

2.2 Por que containers são úteis para desenvolvedores

• Isolamento: Execute em um ambiente limpo e reproduzível sem afetar seu sistema host.
• Reprodutibilidade: Garanta que sua configuração funcione da mesma forma em diferentes máquinas.
• Configuração fácil: Inicie uma instância IRIS em segundos com um único comando, sem uma instalação manual.

2.3 Por que o IRIS funciona bem com Docker

Executar o InterSystems IRIS no Docker tem várias vantagens:

• A aplicação é executada e pode ser testada em containers isolados.
• Permite o uso de sistemas de controle de versão compartilhado (como o Git) em vez de trabalhar diretamente no servidor.
• O ambiente containerizado pode ser replicado em qualquer estágio, permitindo consistência em todo o ciclo de vida de entrega do software..
• Sua aplicação pode ser facilmente executada em qualquer computador.

3.Pré-requisitos

Para executar o InterSystems IRIS em um container Docker, você deve ter:

• Docker Engine instalado e em execução: 
  • Instale o Docker Engine no Linux..
  • O Docker Engine também está disponível para Windows, macOS e Linux, através do Docker Desktop.
• Git para permitir o uso de repositórios de controle de origem (source control) compartilhados.
• Visual Studio Code para visualizar e modificar o código-fonte.

4. Instalando a imagem do InterSystems IRIS

4.1 Usando o Docker Hub

O Docker Hub é o registro central para imagens Docker. Ele oferece uma vasta biblioteca de imagens pré-construídas que você pode usar como ponto de partida. A InterSystems publica lá as imagens oficiais da IRIS Community Edition, que você pode baixar para executar o IRIS localmente em seu container. Você também pode usar o Docker Hub para enviar suas próprias imagens personalizadas para compartilhamento dentro de sua equipe ou distribuição para a comunidade. O Docker Hub está disponível online e incorporado no Docker Desktop.

4.2 Obtendo a Imagem

Alguns comandos comuns de imagem Docker são:

Você pode encontrar o comando de pull exato diretamente na página do Docker Hub da imagem:

Para a imagem do InterSystems IRIS, o comando é:

docker pull intersystems/iris-community:latest-cd

Alternativamente, você pode pesquisar por iris-community dentro da barra de pesquisa do Docker Desktop e clicar em Pull:

Uma vez instalada, a imagem do InterSystems IRIS deve aparecer listada entre suas imagens locais:

5. Executando a Imagem do InterSystems IRIS

Assim que a imagem do InterSystems IRIS for obtida (pulled) do Docker Hub, você pode executá-la dentro de um container.

A seguir, estão comandos comuns para containers Docker:

5.1 Iniciando um Container IRIS

Você pode iniciar um container do InterSystems IRIS Community Edition chamado "my-iris" através da interface do usuário do Docker Desktop simplesmente clicando no botão Run da imagem que você deseja executar no painel Images. Para a imagem do InterSystems, é possível especificar algumas configurações opcionais, como quais portas expor em sua máquina host para se comunicar com os serviços em execução dentro do container.

Isso pode ser feito através do menu mostrado acima, considerando que:

• lado esquerdo → porta na máquina host
• lado direito → porta dentro do container

Portas IRIS Comuns (dentro do container)

• 1972 → Superserver Port: Usada pelo IRIS para protocolos de rede (ObjectScript, JDBC, etc.).
• 52773 → Web Server Port: Usada pelo IRIS para o Management Portal (interface web).

Se você não mapear as portas explicitamente, o Docker atribuirá portas aleatórias no host.

Alternativamente, você pode executar o container usando o terminal:

docker run --name my-iris -d --publish 9091:1972 --publish 9092:52773 intersystems/iris-community:latest-cd

Neste exemplo:

• A porta 9091 no host é mapeada para a porta1972 dentro do container (Superserver).
• A porta 9092 o host é mapeada para a porta 52773dentro do container (Management Portal).

5.2 Verificando o Status do Container

Após executar este comando, execute docker ps para verificar se o container está sendo executado corretamente.

> docker ps
CONTAINER ID   IMAGE                                   COMMAND                 CREATED         STATUS                            PORTS                                                                                        NAMES
907d4c2b4ab5   intersystems/iris-community:latest-cd   "/tini -- /iris-main"   3 seconds ago   Up 2 seconds (health: starting)   0.0.0.0:9091->1972/tcp, [::]:9091->1972/tcp, 0.0.0.0:9092->52773/tcp, [::]:9092->52773/tcp   my-iris

Os containers em execução também são listados no painel Containers do Docker Desktop:

O status das imagens relacionadas será "In Use" (Em uso), conforme mostrado no painel Images:

5.3 Executar código no terminal do container

Assim que o status do container mostrar Running, tudo estará funcionando corretamente.

Você pode testar abrindo o terminal do container (clique no nome do container no painel do Docker Desktop e vá em Exec) e digitando:

 

iris session IRIS

Isso abre um terminal IRIS dentro do container Docker, onde você pode usar a sintaxe padrão ObjectScript para executar comandos e scripts.

5.4 Acessando o Portal de Gerenciamento IRIS da instância em container

Em seguida, abra seu navegador e navegue para:

http://localhost:9092/csp/sys/UtilHome.csp

or padrão, os containers IRIS usam o usuário _SYSTEM com a senha SYS. Você será solicitado a alterar a senha após o primeiro login.

Isso lhe dá acesso total ao Portal de Gerenciamento IRIS, permitindo gerenciar namespaces, bancos de dados e outros recursos do IRIS diretamente pela interface web.

5.5 Conectando o container ao IDE VSCode

Você pode conectar seu IDE preferido (como VS Code ou Studio) ao container IRIS usando a porta mapeada do Superserver (padrão 1972 dentro do container, ex: 9091 no host) e a porta do Web Server (padrão 52773 dentro do container, ex: 9092 no host). Isso permite desenvolver e testar código ObjectScript diretamente no container em execução.

Para conectar o container ao VSCode:

• Instale o InterSystems ObjectScript Extension Pack
• Abra a extensão InterSystems Server.
• Clique nos três pontos e em "Edit server".
• Clique em "Edit in settings.json".
• Adicione este elemento ao JSON intersystems.servers:

"docker_iris": {
    "webServer": {
        "scheme": "http",
        "host": "localhost",
        "port": 9092
    },
    "description": "Connection to Docker container."
}

• Agora o servidor está conectado. Você pode fazer login com o usuário _SYSTEM.
• Como você pode ver, o namespace USER é o único disponível.

5.6 Parando ou removendo o container

Para parar um container em execução, use o comando:

docker stop my-iris

Iniciar o container novamente:

Para iniciar o container parado, use:

docker start my-iris

Remover (deletar) o container:

Para remover a instância do container, mas manter a imagem, use:

docker rm my-iris

Todos os dados dentro do container serão perdidos, a menos que você tenha montado volumes (falaremos sobre isso nos próximos parágrafos).

5.7 Sefinir uma senha específica usando bind mount

É possível definir uma senha personalizada ao iniciar um container usando um arquivo de senha. O arquivo será salvo no seu host e copiado para o container através do mecanismo de bind mount.

Ao usar um bind mount, um arquivo ou diretório da máquina host é montado dentro do container, permitindo compartilhar código-fonte ou artefatos de build entre o ambiente de desenvolvimento no host Docker e o container.

• Crie um arquivo chamado password.txt contendo apenas sua senha como uma string (Atenção! Anote sua senha, você precisará dela depois).
• Copie o caminho do arquivo; neste exemplo éC:\InterSystems\DockerTest\password\password.txt
• Execute o seguinte comando:

docker run --name my-iris -d --publish 9091:1972 --publish 9092:52773 --volume "C:\InterSystems\DockerTest:/durable" intersystems/iris-community:latest-cd --password-file /durable/password/password.txt 

Assim que o container estiver rodando, você pode logar com o usuário _SYSTEM e a senha que escreveu no arquivo.

Dentro do container Docker, você verá um arquivo password.txt.done. O mesmo arquivo estará na pasta do seu host.

A extensão do arquivo é alterada para .done para evitar que a senha fique em texto simples. Este é o comportamento padrão no InterSystems IRIS com arquivos de senha. Após a senha ser lida e o usuário padrão (_SYSTEM) ser atualizado, o arquivo é renomeado e o conteúdo removido por motivos de segurança.

Você pode logar no Portal de Gerenciamento usando sua senha personalizada. (Eu falei para você anotar :D) O IRIS não forçará a troca de senha após o login.

Nota: Se o container for removido e reiniciado sem um volume durável montado, a senha não será lida novamente do arquivo (pois ele virou .done). Nesse caso, a senha padrão "SYS" será usada.

5.8 Iniciar container com um volume durável específico

Por padrão, qualquer coisa salva dentro de um container Docker desaparece quando você o remove com o comando docker rm <container's name> . 

Para evitar a perda de dados, o InterSystems IRIS oferece o recurso durable %SYS feature. Isso permite que a instância armazene arquivos importantes na sua máquina host.

5.8.1 O que é armazenado com o durable %SYS?

Exemplos incluem:

• Arquivos de configuração (iris.cpf, httpd.conf)
• Configurações e logs do Web Gateway (/csp)
• Bancos de dados do sistema (IRIS, USER, IRISSECURITY, IRISTEMP, etc.)
• Journals, arquivos de imagem de gravação (WIJ) e arquivos temporários
• Arquivos de log (messages.log, SystemMonitor.log, etc.)
• Chave de licença (iris.key)
• Quaisquer outros bancos de dados criados por você

5.8.2 Como habilitar o durable %SYS

O primeiro passo é escolher uma pasta no seu host, comoC:\InterSystems\DockerTest

• No Linux: Certifique-se de que o IRIS pode escrever nela criando o usuário irisowner e dar a ele direitos de administrador do diretório:

adduser irisowner
chown -R irisowner:irisowner /InterSystems/DockerTest

• No Windows: Você pode pular este passo pois o Docker Desktop montará a pasta com as permissões do seu usuário atual.

Em seguida, monte a pasta do host e informe ao IRIS onde gravar os dados duráveis usando a variável ISC_DATA_DIRECTORY:

  --volume "C:\InterSystems\DockerTest:/durable" --env ISC_DATA_DIRECTORY=/durable/iris

O comando completo para o terminal é:

docker run --name my-iris -d --publish 9091:1972 --publish 9092:52773 --volume "C:\InterSystems\DockerTest:/durable" --env ISC_DATA_DIRECTORY=/durable/iris intersystems/iris-community:latest-cd --password-file /durable/password/password.txt

Ao inspecionar o container, você verá que uma pasta durável está montada contendo os diretórios iris/ e password/. No seu host, você verá os mesmos diretórios.

Se o container for parado e removido, ao recriá-lo com o mesmo comando, o IRIS restaurará seu estado anterior (usuários, configs, bancos de dados) usando os dados da pasta iris/. Nada é perdido. 

Você pode testar isso criando uma aplicação web, parando e removendo o container e criando-o uma segunda vez. Sem usar o recurso durable %SYS, quaisquer alterações dentro do %SYS são perdidas quando o container é removido, e a instância é iniciada como uma nova a cada vez.

Observe que, se você deletar a pasta iris/, na próxima vez que iniciar o container, o IRIS será inicializado como em uma instalação limpa, pois não encontrará os dados anteriores do %SYS. Uma pasta iris/ nova será criada.

6. Usando Docker Compose 

Até agora, você iniciou o InterSystems IRIS com um único comando docker run longo. Isso funciona, mas rapidamente se torna difícil gerenciar tudo apenas com comandos de shell.

O Docker Compose é um arquivo de configuração YAML para definir como executar um ou mais containers. Ele simplifica o controle de toda a sua pilha de aplicações (stack), facilitando o gerenciamento de serviços, redes e volumes. Com um único comando, você pode criar e iniciar todos os serviços do seu arquivo de configuração.

Abaixo estão os comandos comuns do Docker Compose:

6.1 Exemplo de Docker Compose

Para usar o Docker Compose, você deve criar um arquivo docker-compose.yml contendo todas as configurações do container que deseja iniciar.

Desta forma, o comando

docker run --name my-iris -d --publish 9091:1972 --publish 9092:52773 --volume "C:\InterSystems\DockerTest:/durable" --env ISC_DATA_DIRECTORY=/durable/iris intersystems/iris-community:latest-cd --password-file /durable/password/password.txt

anterior pode ser substituído pelo arquivo abaixo:

# docker-compose.yml     
services:
  iris:
    container_name: my-iris
    image: intersystems/iris-community:latest-cd
    init: true
    volumes:
      # Dados do sistema/persistentes (instalação IRIS, bancos de dados, etc.)
      # No windows, você também pode usar  "C:\\InterSystems\\DockerTest:/durable"
      - C:/InterSystems/DockerTest:/durable
    ports:
      - "9092:52773"  # Portal de Gerenciamento / APIs REST
      - "9091:1972"   # Porta do SuperServer
    environment:
      - ISC_DATA_DIRECTORY=/durable/iris
    # Usa o arquivo de senha para logar dentro do container
    command: --password-file /durable/password/password.txt

6.2 Executando o Docker Compose

Abra um terminal no diretório onde o arquivo está salvo (ou use a opção -f) e execute:

docker compose up -d

Seu container IRIS iniciará com a configuração exata especificada no arquivo.

No Docker Desktop, você verá que uma stack chamada "dockertest" (nome da pasta onde o arquivo está salvo) foi criada e associada ao container "my-iris".

7. Usando um Dockerfile para executar código-fonte personalizado

Até agora, você tem executado o InterSystems IRIS diretamente da imagem oficial do Docker. No entanto, podemos precisar carregar automaticamente classes ObjectScript ou outro código personalizado dentro da imagem durante a sua construção (build).

Um Dockerfile é um arquivo de texto com instruções para construir uma imagem, partindo de uma imagem base (como intersystems/iris-community:latest-cd). Com um Dockerfile, podemos adicionar código-fonte personalizado ao contêiner e executar comandos customizados durante a criação da imagem.

7.1 Exemplo de Dockerfile

O próximo exemplo fornece um Dockerfile que executa as seguintes operações:

• Inicia a imagem a partir da imagem oficial do InterSystems IRIS.
• Copia o código da sua aplicação da pasta src/ para dentro do contêiner.
• Executa um script para importar classes, inicializar a aplicação conteinerizada e salvar os registros em um arquivo de log.
• Expõe as portas padrão do InterSystems IRIS.

7.2 Exemplo de Docker Compose

Você deve modificar o Docker Compose também, para especificar que a imagem deve ser construída a partir do Dockerfile na pasta atual:

# docker-compose.yml     
services:
  iris:
    container_name: my-iris
    build: # isso diz ao Docker para construir uma nova imagem baseada no Dockerfile especificado
      context: .        #constrói a imagem a partir do Dockerfile local
      dockerfile: Dockerfile
    image: my-modified-iris-image:latest   #dê à nova imagem uma nova tag para evitar sobrescrever a imagem base
    init: true
    volumes:
      # Dados do sistema/persistentes (instalação do IRIS, bancos de dados, etc.)
      # No Windows, você pode usar: "C:\\InterSystems\\DockerTest:/durable"
      - C:/InterSystems/DockerTest:/durable
    ports:
      - "9092:52773"  # Portal de Administração / APIs REST
      - "9091:1972"   # Porta do SuperServer
    environment:
      - ISC_DATA_DIRECTORY=/durable/iris
    # Usa o arquivo de senha para logar dentro do contêiner
    command: --password-file /durable/password/password.txt

7.3 Entendendo camadas, tags de imagem e tempo de build vs. execução

No Docker, existem dois princípios importantes a serem lembrados (Sugestão de leitura O que é uma imagem?)

1. Imagens são imutáveis: Uma vez criada, uma imagem não pode ser modificada. Você só pode criar uma nova imagem ou adicionar alterações sobre ela.
2. Imagens de contêiner são compostas por camadas: Cada camada representa um conjunto de alterações no sistema de arquivos (adicionar, remover ou modificar arquivos).

Novas camadas são adicionadas a uma imagem quando as instruções especificadas em um Dockerfile são executadas.

É fundamental distinguir o que o Docker faz no build time (tempo de construção — quando cria a imagem) e no run time (tempo de execução — quando inicia um contêiner).

Instruções executadas no build time:

• COPY: arquivos são copiados para a imagem.
• RUN:executa comandos e salva os resultados como novas camadas da imagem.
• ENTRYPOINT: define o processo padrão que será lançado na execução (não altera o sistema de arquivos).
• EXPOSE:define metadados sobre quais portas a imagem pretende usar.

No run time, o Docker não reconstrói a imagem, mas adiciona uma "camada de contêiner" temporária sobre ela. Todas as mudanças feitas enquanto o contêiner está rodando (novos arquivos, edições, logs) vão para esta camada temporária.

Do último exemplo de Docker Compose:

build: # isso diz ao Docker para construir uma nova imagem baseada no Dockerfile especificado
  context: .        #constrói a imagem a partir do Dockerfile local
  dockerfile: Dockerfile
image: my-modified-iris-image:latest   #dê à nova imagem uma nova tag para evitar sobrescrever a imagem base

Essas instruções dizem ao Docker para criar uma nova imagem chamada my-modified-iris-image:latest (isso é chamado de tag), baixando a imagem base e modificando-a conforme descrito no Dockerfile. Marcar a nova imagem com um nome distinto é muito importante. Se evitarmos colocar uma tag na imagem recém-criada, a imagem base será sobrescrita pela nova. A imagem oficial ainda estará disponível no Docker Hub, mas esta versão local a "ofuscará" (shadow), e cada projeto que se referir a essa tag passará a usar, sem saber, a imagem personalizada contendo várias camadas novas.

Para evitar isso, use sempre uma tag distinta para criar uma nova imagem separada, mantendo a imagem base oficial limpa e reutilizável.

7.4 Código-fonte e script de inicialização

Neste ponto, devemos criar pelo menos uma classe e colocá-la dentro da pasta src/. A classe será copiada para o contêiner e importada através do arquivo iris.script, que contém todas as instruções para importar as classes e inicializar a aplicação durante a construção da imagem.

Crie um novo diretório chamado src/DockerStepByStep na pasta do seu projeto e crie o seguinte arquivo de classe:

Class DockerStepByStep.cheers Extends %RegisteredObject
{

ClassMethod sayHi() As %Status
{
    Set sc = $$$OK
    w "Hi mom!",!
    Return sc
}

}

Na raiz do seu projeto, crie um arquivo chamado iris.script:

// Remove a expiração de senhas para o modo de desenvolvimento
zn "%SYS"
zn "%SYS"
Do ##class(Security.Users).UnExpireUserPasswords("*")

// Carrega classes da origem durável
zn "USER"
// Importa classes
set importPath = "/opt/irisapp/src"
write "Loading classes at '", importPath, "' ...", !
set errors = ""
do $System.OBJ.Import(importPath,"cuk",,.errors)
if errors = 0 { write "Classes loaded successfully", ! } else { write errors, " errors occurred while loading classes!", ! }

halt

7.5 Construir Imagem com Dockerfile

Para a primeira execução, você pode usar o seguinte comando para construir a imagem a partir do Dockerfile (a flag --build força o Docker a reconstruir a imagem):

docker-compose up --build

Para as próximas vezes, se o Dockerfile não tiver sido modificado, você pode simplesmente rodar:

docker-compose up -d

Assim que a construção da imagem iniciar, você verá estes logs no terminal:

PS C:\InterSystems\DockerTest> docker-compose up --build
[+] Building 21.5s (13/13) FINISHED
 => [internal] load local bake definitions                                                                     0.0s
 => => reading from stdin 530B                                                                                 0.0s
 => [internal] load build definition from Dockerfile                                                           0.0s
 => => transferring dockerfile: 1.73kB                                                                         0.0s
 => [internal] load metadata for docker.io/intersystems/iris-community:latest-cd                              10.0s
 => [internal] load .dockerignore                                                                              0.0s
 => => transferring context: 2B                                                                                0.0s
 => [1/6] FROM docker.io/intersystems/iris-community:latest-cd@sha256:93488df381f5868649e7bfc33a9083a3e86a22d  0.9s
 => => resolve docker.io/intersystems/iris-community:latest-cd@sha256:93488df381f5868649e7bfc33a9083a3e86a22d  0.0s
 => [internal] load build context                                                                              0.0s
 => => transferring context: 147B                                                                              0.0s
 => [2/6] WORKDIR /opt/irisapp                                                                                 0.0s
 => [3/6] COPY src src                                                                                         0.1s
 => [4/6] COPY iris.script .                                                                                   0.1s
 => [5/6] RUN mkdir -p /opt/irisapp/logs                                                                       0.3s
 => [6/6] RUN iris start IRIS &&     iris session IRIS < iris.script > /opt/irisapp/logs/build.log 2>&1 &&     4.5s
 => exporting to image                                                                                         4.5s
 => => exporting layers                                                                                        3.3s
 => => exporting manifest sha256:3ce316cefa21a3707251c4287005a15b02e6dc0151b24baf2a82f76064792250              0.0s
 => => exporting config sha256:00238e19edef86b29149d2eb89ff75f4d1465ba0d9a2ac4494a14d3bd3746a94                0.0s
 => => exporting attestation manifest sha256:3579cab5c8accc7958090276deb60bd7dbbc2ecbf13af8e7fa8c4ff2dfe91028  0.0s
 => => exporting manifest list sha256:17b969c340f57d611cc7603287cc6db50cffd696258a72b5648ece0a919676ac         0.0s
 => => naming to docker.io/intersystems/iris-community:latest-cd                                               0.0s
 => => unpacking to docker.io/intersystems/iris-community:latest-cd                                            0.9s
 => resolving provenance for metadata file                                                                     0.0s
[+] Running 3/3
 ✔ intersystems/iris-community:latest-cd  Built                                                                0.0s
 ✔ Network dockertest_default             Created                                                              0.1s
 ✔ Container my-iris                      Created                                                              0.2s 

No passo 6/6, o arquivo iris.script é executado na instância IRIS conteinerizada e os logs são salvos no caminho /opt/irisapp/logs/build.log.

Para visualizar os logs, você pode executar o comando:

docker exec -it my-iris cat /opt/irisapp/logs/build.log

Você deverá ver os registros informando sobre o resultado da compilação da classe, terminando com:

Node: buildkitsandbox, Instance: IRIS

USER>

USER>

%SYS>

%SYS>

%SYS>

%SYS>

USER>

USER>

USER>

USER>
Loading classes at '/opt/irisapp/src' ...

USER>

USER>

Load of directory started on 09/16/2025 07:46:28
Loading file /opt/irisapp/src/DockerStepByStep/cheers.cls as udl

Compilation started on 09/16/2025 07:46:28 with qualifiers 'cuk'
Class DockerStepByStep.cheers is up-to-date.
Compilation finished successfully in 0.005s.

Load finished successfully.

USER>
Classes loaded successfully

USER>

USER>

No Docker Desktop, você poderá ver que uma nova imagem chamada my-modified-iris-image foi criada e está rodando ao lado da imagem oficial base.

. Se você inspecionar as imagens, verá que a personalizada é composta por 31 camadas, em vez das 25 camadas da original.

7.6 Executar instruções no terminal do IRIS conteinerizado

Para testar as classes, você pode ativar o terminal do IRIS dentro da instância conteinerizada. Para isso, execute a seguinte instrução:

docker exec -it my-iris iris session IRIS

Neste ponto, você pode invocar o ClassMethod a partir do namespace USER com o comando:

do ##class(DockerStepByStep.cheers).sayHi()

Finalmente, você deverá ver a saída:

PS C:\InterSystems\DockerTest> docker exec -it my-iris iris session IRIS
   
Node: 41c3c7a9f2e4, Instance: IRIS

USER>do ##class(DockerStepByStep.cheers).sayHi()
Hi mom!

8. Conclusão e próximos passos

Percorremos o ciclo completo de colocar o InterSystems IRIS para rodar no Docker:

• Baixar (pull) a imagem.
• Iniciar e configurar contêineres.
• Persistir dados com %SYS durável.
• Construir imagens personalizadas com seu próprio código e scripts.

Isso é o suficiente para começar a experimentar o IRIS em um ambiente de contêiner e usá-lo para desenvolvimento.

Um repositório GitHub com todos os arquivos discutidos (Docker Compose, Dockerfile, iris.script, etc.) está disponível.

Fique atento ao próximo artigo!