Pesquisar

Artigo
· 1 hr atrás 12min de leitura

Data Streaming com interoperabilidade do InterSystems IRIS

As arquiteturas de dados modernas utilizam soluções de captura, transformação, movimentação e carregamento de dados em tempo real para construir data lakes, data warehouses analíticos e repositórios de big data. Isso permite a análise de dados de diversas fontes sem impactar as operações que os utilizam. Para alcançar esse objetivo, é essencial estabelecer um fluxo de dados contínuo, escalável, elástico e robusto. O método mais comum para isso é a técnica de CDC (Change Data Capture). O CDC monitora a produção de pequenos conjuntos de dados, captura esses dados automaticamente e os entrega a um ou mais destinatários, incluindo repositórios de dados analíticos. O principal benefício é a eliminação do atraso D+1 na análise, já que os dados são detectados na origem assim que são produzidos e, posteriormente, replicados para o destino.

Este artigo demonstrará as duas fontes de dados mais comuns para cenários de CDC, tanto como origem quanto como destino. Para a origem dos dados, exploraremos o CDC em bancos de dados SQL e arquivos CSV. Para o destino dos dados, utilizaremos um banco de dados colunar (um cenário típico de banco de dados analítico de alto desempenho) e um tópico do Kafka (uma abordagem padrão para transmitir dados para a nuvem e/ou para vários consumidores de dados em tempo real).

Visão Breve

Este artigo fornecerá um exemplo para o seguinte cenário de interoperabilidade:

 

  1. O SQLCDCAdapter utilizará o SQLInboundAdapter para detectar novos registros no banco de dados SQL e extraí-los com a ajuda de uma conexão JDBC e da linguagem SQL.
  2. O SQLCDCAdapter encapsulará os dados capturados em uma mensagem e a enviará para o CDCProcess (um Processo de Negócio usando a notação BPL).
  3. O CDCProcess recebe os dados SQL como uma mensagem e utiliza a Operação SQL para persistir os dados no IRIS e a Operação Kafka para transmitir os dados capturados para um tópico do Kafka.
  4. A Operação SQL persistirá os dados da mensagem em uma Classe Persistente do InterSystems IRIS modelada como armazenamento colunar.
  5. O armazenamento colunar é uma opção que oferece desempenho superior em consultas para dados analíticos.
  6. A Operação Kafka transformará a mensagem em JSON e a enviará para um tópico do Kafka, onde um data lake na nuvem ou qualquer outro assinante poderá consumi-la.
  7. Esses fluxos de dados são executados em tempo real, estabelecendo um fluxo de dados contínuo.
  8. O Serviço BAM calculará as métricas de negócios a partir da tabela colunar em tempo real. Um painel de BI exibirá as métricas de negócios resultantes para o usuário instantaneamente.

Instalando o exemplo

O pacote iris-cdc-sample (https://openexchange.intersystems.com/package/iris-cdc-sample) é um aplicativo de exemplo que implementa o cenário descrito acima. Para instalá-lo, siga estas etapas:

1. Clone/git pull o repositório em qualquer diretório local:

$ git clone https://github.com/yurimarx/iris-cdc-sample.git

2. Abra o terminal neste diretório e execute o comando abaixo:

$ docker-compose build

3. Execute o contêiner IRIS com seu projeto:

$ docker-compose up -d


Componentes do exemplo

Este exemplo utiliza os seguintes contêineres:

  • iris: Plataforma InterSystems IRIS, incluindo:
    • Banco de Dados Colunar IRIS (para armazenar os dados capturados).
    • Interoperabilidade IRIS com um ambiente de produção para executar o processo de CDC (captura de dados de alteração). A produção captura dados de um banco de dados externo (PostgreSQL), os persiste no IRIS e os transmite para um tópico do Kafka.
    • IRIS BAM (Monitoramento de Atividade Comercial) para calcular métricas de vendas em tempo real por produto e exibi-las em um painel.
  • salesdb: Um banco de dados PostgreSQL contendo dados de vendas a serem capturados em tempo real.
  • zookeeper: Um serviço usado para gerenciar o broker Kafka.
  • kafka: O broker Kafka com o tópico de vendas, utilizado para receber e distribuir dados de vendas como eventos em tempo real.
  • kafka-ui: Uma interface web do Kafka para administração e operação de tópicos e eventos.
services:
  iris:
    build:
      context: .
      dockerfile: Dockerfile
    restart: always
    command: --check-caps false --ISCAgent false
    ports:
      - 1972
      - 52795:52773
      - 53773
    volumes:
      - ./:/home/irisowner/dev/
    networks:
      - cdc-network
  salesdb:
    image: postgres:14-alpine
    container_name: sales_db
    restart: always
    environment:
      POSTGRES_USER: sales_user
      POSTGRES_PASSWORD: welcome1
      POSTGRES_DB: sales_db
    volumes:
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
      - postgres_data:/var/lib/postgresql/data/
    ports:
      - "5433:5432"
    networks:
      - cdc-network


  zookeeper:
      image: confluentinc/cp-zookeeper:7.5.0
      container_name: zookeeper
      hostname: zookeeper
      networks:
        - cdc-network
      ports:
        - "2181:2181"
      environment:
        ZOOKEEPER_CLIENT_PORT: 2181
        ZOOKEEPER_TICK_TIME: 2000
  kafka:
    image: confluentinc/cp-kafka:7.5.0
    container_name: kafka
    hostname: kafka
    networks:
      - cdc-network
    ports:
      - "9092:9092"
    depends_on:
      - zookeeper
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://kafka:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
  kafka-ui:
      image: provectuslabs/kafka-ui:latest
      container_name: kafka-ui
      hostname: kafka-ui
      networks:
        - cdc-network
      ports:
        - "8080:8080"
      depends_on:
        - kafka
      environment:
        KAFKA_CLUSTERS_0_NAME: local_kafka_cluster
        KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:29092
volumes:
  postgres_data:
    driver: local


networks:
  cdc-network:
    driver: bridge

Criando uma tabela colunar

Tabelas colunares são utilizadas para armazenar dados não normalizados, como os seguintes:

Nome do produto

Nome Loja

Valor venda (Price)

Orange

Store 1

120

Orange 

Store 1

200

Banana

Store 2

100

Banana

Store 1

120

Orange

Store 2

110

Como os valores de Nome do Produto e Nome da Loja se repetem com frequência, armazenar os dados em formato colunar (como colunas em vez de linhas) conserva espaço de armazenamento e proporciona um desempenho superior na recuperação de dados. Historicamente, esse tipo de processamento exigia a criação de cubos de BI. No entanto, o armazenamento colunar resolve esse problema, eliminando a necessidade de replicar dados operacionais em cubos.
Agora, siga estas etapas para criar a tabela colunar de Vendas para o nosso exemplo:

1. Crie uma nova classe ObjectScript chamada Sales dentro do pacote dc.cdc.

2. Escreva o seguinte código-fonte:

Class dc.cdc.Sales Extends %Persistent [ DdlAllowed, Final ]
{

Parameter STORAGEDEFAULT = "columnar";
Parameter USEEXTENTSET = 1;
Property ProductName As %String;
Property StoreName As %String;
Property SalesValue As %Double;
}

3. O parâmetro STORAGEDEFAULT = "columnar" configura a tabela dc_cdc.Sales para usar columnar storage, ao invés de usar linha.

Criando a operação comercial para salvar os dados capturados

Após capturar os dados de vendas em um StreamContainer usando o SalesSqlService (nenhuma implementação é necessária; a configuração é feita no ambiente de produção na seção "Executando CDC"), precisamos de uma Operação de Negócios para processar o StreamContainer, extrair os dados de vendas do PostgreSQL e salvá-los na tabela Sales. Execute os passos abaixo:
1. Crie a classe SalesOperation dentro do pacote dc.cdc.
2. Escreva o código-fonte abaixo:

Class dc.cdc.SalesOperation Extends Ens.BusinessOperation
{

Method ProcessSalesData(pRequest As Ens.StreamContainer, Output pResponse As Ens.StringResponse) As %Status
{
    Set tSC = $$$OK
    Set pResponse = ##class(Ens.StringResponse).%New()

    Try {
        
        Set tStream = pRequest.Stream
        
        Do tStream.Rewind()

        Set content = ""
        While 'tStream.AtEnd {
            Set content = content _ tStream.Read(4096) 
        }

        Set tDynamicObject = {}.%FromJSON(content)
        
        Set sales = ##class(dc.cdc.Sales).%New()
        Set sales.ProductName = tDynamicObject."product_name"
        Set sales.StoreName = tDynamicObject."store_name"
        Set sales.SalesValue = tDynamicObject."sales_value"
        Set tSC = sales.%Save()

        Set pResponse.StringValue = tDynamicObject.%ToJSON()
        
    } Catch (ex) {
        Set tSC = ex.AsStatus()
        Set pResponse.StringValue = "Error while saving sales data!"
        $$$LOGERROR("Error while saving sales data: " _ ex.DisplayString())
    }

    Quit tSC
}

XData MessageMap
{
<MapItems>
  <MapItem MessageType="Ens.StreamContainer">
    <Method>ProcessSalesData</Method>
  </MapItem>
</MapItems>
}

}

3. O método ProcessSalesData receberá mensagens do tipo StreamContainer (devido à definição de MessageMap).

4. O método lerá os dados de vendas capturados em uma string JSON, carregará o JSON em um DynamicObject, criará um objeto Sales, definirá os valores de suas propriedades e o salvará na tabela Sales.

5. Finalmente, o método retornará a string JSON representando os dados de vendas na resposta.

 

Criando o serviço do BAM para monitorar vendas (Sales)

O InterSystems IRIS para Interoperabilidade inclui a funcionalidade BAM, permitindo monitorar dados de negócios em tempo real processados ​​em produção usando um Painel de Análise. Para criar o serviço BAM, siga os passos abaixo:
1. Crie uma nova classe chamada SalesMetric que estenda Ens.BusinessMetric no pacote dc.cdc.
2. Escreva o seguinte código-fonte:

Class dc.cdc.SalesMetric Extends Ens.BusinessMetric
{

Property TotalSales As Ens.DataType.Metric(UNITS = "$US") [ MultiDimensional ];
Query MetricInstances() As %SQLQuery
{
  SELECT distinct(ProductName) FROM dc_cdc.Sales
}

/// Calculate and update the set of metrics for this class
Method OnCalculateMetrics() As %Status
{
    Set product = ..%Instance
    Set SalesSum = 0.0
    &sql(
        select sum(SalesValue) into :SalesSum from dc_cdc.Sales where ProductName = :product 
    )

    Set ..TotalSales = SalesSum

    Quit $$$OK
}

}

3. A propriedade TotalSales permite o monitoramento em tempo real da soma das vendas por produto.
4. A propriedade Query MetricInstances define quais produtos devem ser monitorados.
5. O método OnCalculateMetrics calcula a soma das vendas para cada produto.
6. Esta classe será utilizada em um painel para gerar o total de vendas por produto em tempo real.

Executando o Processo e Produção do CDC - Change Data Capture


Nosso diagrama de produção final, com todos os processos ETL (Extração, Transformação e Carga) necessários, é mostrado abaixo:

 

Siga os próximos passos:

1. Acesse o ambiente de produção do CDC: http://localhost:52795/csp/user/EnsPortal.ProductionConfig.zen?PRODUCTIO...
2. Crie um novo EnsLib.JavaGateway.Service chamado Java (necessário para o SalesSqlService).

3. Gere um serviço de negócios chamado SalesSqlService (SQLCDCService) e configure os seguintes parâmetros:

a. DSN (string de conexão para PostgreSQL): jdbc:postgresql://sales_db:5432/sales_db.

b. Credenciais: Crie um pg_cred com o nome de usuário (sales_user) e a senha (welcome1) para acessar o PostgreSQL.

c. Nomes de configuração de destino: SalesProcess (o processo do CDC).

d. Consulta (para selecionar os dados a serem consumidos): select * from sales.

e. Nome do Campo Chave (a coluna que o IRIS usa para rastrear linhas já capturadas): id.
f. Serviço Java Gateway (obrigatório porque o adaptador CDC usa JDBC): Java (Java Gateway para esta produção).

g. Driver JDBC: org.postgresql.Driver.

h. Classpath JDBC (um driver para conectar com o PostgreSQL, copiado via script Dockerfile): /home/irisowner/dev/postgresql-42.7.8.jar.

4. Crie uma nova instância de dc.cdc.SalesMetric chamada SalesMetric.

5. Gere uma nova instância de EnsLib.Kafka.Operation e nomeie-a como SalesKafkaOperation (Operação Kafka) com os seguintes parâmetros:

a. ClientID: iris
b. Servers: kafka:9092

6. Crie uma nova instância de dc.cdc.SalesOperation chamada SalesOperation.

7. Desenvolva um Processo de Negócio chamado SalesProcess. A lógica de implementação do BPL deve ser a seguinte:

a. Diagrama final:

 

b. Crie 2 propriedades no Context:

i. `Sales` com o tipo `Ens.StringResponse` para armazenar os dados de vendas como uma string JSON.
ii. `KafkaMessage` com o tipo `EnsLib.Kafka.Message` (para ser usado para enviar os dados capturados para o tópico `sales-topic` do Kafka).

c. Gere uma chamada, salve na tabela `Sales` e defina o seguinte:

i. Destino: `SalesOperation`
ii. Classe da mensagem de solicitação: `Ens.StreamContainer` (dados capturados como fluxo)
iii. Ações da solicitação:

 

iv. Classe da mensagem de resposta: Ens.StringResponse (o fluxo será convertido em uma representação em string JSON dos dados capturados)

v. Ações de resposta:

 

d. Crie um bloco de código e escreva um código ObjectScript que preencha a mensagem do Kafka com as propriedades necessárias para que os dados de vendas (como uma string JSON) sejam publicados como um evento no tópico de vendas do broker do Kafka:

Set context.KafkaMessage.topic = "sales-topic"
Set context.KafkaMessage.value = context.Sales.StringValue 
Set context.KafkaMessage.key = "iris"

e. Crie uma chamada para o tópico de vendas do Kafka e defina o seguinte design:

i. Destino: SalesKafkaOperation
ii. Classe da mensagem de solicitação: %Library.Persistent (KafkaMessage é persistente)
iii. Ações da solicitação:

 

f. Crie uma atribuição chamada "Enviar Resposta" com o seguinte conteúdo:

i. Propriedade: response.StringValue
ii. Valor: "Processo finalizado!"

 

Vendo os resultados do CDC

Após habilitar o CDCProduction, insira alguns registros na tabela de vendas do PostgreSQL usando sua ferramenta de administração de banco de dados (DBeaver ou PgAdmin) e observe os resultados das mensagens de produção.

 

Consulte o diagrama de sequência para entender o processo do CDC (clique em qualquer link do cabeçalho da mensagem):

 

Visualizando o monitoramento do BAM em um painel de análise

Ao capturar dados em tempo real, você naturalmente deseja visualizar os resultados instantaneamente em um painel. Siga os passos abaixo para conseguir isso:
1. Acesse Analytics > Portal do Usuário (User Portal):

 

2. Clique Add Dashboard:

 

3. Defina as propriedades abaixo e clique em OK:

a. Pasta: Ens/Analytics
b. Nome do painel: Sales BAM

4. Clique em Widgets:

 

5. Clique o botão mais:

 

6. Configure the Widget as shown below:
 

7. Ajuste o novo widget para cobrir toda a área do painel.

8. Agora, selecione WidgetSales:

9. Escolha Controls:
  

10. Clique no botão mais:
  

11. Configure o controle conforme ilustrado abaixo (para visualizar o total de vendas em tempo real, com atualização automática):

12. Agora, quando novos valores forem capturados, o painel exibirá imediatamente os valores atualizados para TotalSales.

Para aprender mais:

A documentação da InterSystems pode ajudá-lo a aprofundar seus conhecimentos em CDC, BAM, Kafka e interoperabilidade. Visite as páginas abaixo para saber mais:

  1. BAM: https://docs.intersystems.com/iris20252/csp/docbook/Doc.View.cls?KEY=EGIN_options#EGIN_options_bam  
  2. Kafka: https://docs.intersystems.com/iris20252/csp/docbook/Doc.View.cls?KEY=ITECHREF_kafka 
  3. Adaptadores SQL (CDC para tabelas SQL): https://docs.intersystems.com/iris20252/csp/docbook/Doc.View.cls?KEY=ESQL_intro
  4. Criando produções de ETL/CDC: https://docs.intersystems.com/iris20252/csp/docbook/Doc.View.cls?KEY=PAGE_interop_languages
  5. BPL (low code para processos de negócio): https://docs.intersystems.com/iris20252/csp/docbook/Doc.View.cls?KEY=EBPL_use

 

Discussão (0)1
Entre ou crie uma conta para continuar
Artigo
· 4 hr atrás 4min de leitura

IKO Plus: Shhhhhhhhh - Secrets Management for IRIS Clusters with External Secrets Operator

Now Under Heavy Rotation, Your IrisCluster Secrets

A few days before Kubecon, the external-secrets-operator went GA with 1.0.0 and is set to ride shotgun for Kubernetes Secrets Management and put Vault in the backseat.  You can glance at the "Providers" list for the solution and immediatley understand that you can leave the "which Secrets Manager" conversation to others while you do your job utilizing external secrets on your IrisCluster workloads, which by my count with the operator and a single IrisCluster is more than a fistful of secrets of different types, even under a single tenant.  So let them sprawl, the secrets managers that is, not the secrets.

Distraction

Lets generate a pull secret in Google Cloud Secret Manager for use with the InterSystems Kubernetes Operator from containers.intersystems.com and use the secret to pull the protected iko image.

Cluster

Lets stand up a k0s cluster for use locally.

# Download k0s
curl -sSLf https://get.k0s.sh | sudo sh

# Install k0s as a service
sudo k0s install controller --single

# Start k0s as a service
sudo k0s start

# Check service, logs and k0s status
sudo k0s status

image.png

The Secret

We need to generate a secret for containers.intersystems.com and jam it in Google Cloud Secret Manager for starters.

In Google Cloud, enable Secrets Manager

gcloud auth login
gcloud config set project ikoplus
gcloud services enable secretmanager.googleapis.com

Now, lets create a docker secret from containers.intersystems.com

docker login -u="ron.sweeney@integrationrequired.com" -p="someOfYourbaseAreBelongToUs" containers.intersystems.com

This will create a config.json somewhere on your system, we now need to jam it in GCP as a secret.

gcloud secrets create ikoplus-eso-gcp \
  --project="ikoplus" \
  --replication-policy="automatic" \
  --data-file=./config.json

 

External Secrets Operator

Lets install the external-secrets-operator itself, and wire up the Google Secret Manager to our new resource type: SecretStore.

Install the Chart

helm repo add external-secrets https://charts.external-secrets.io

helm install external-secrets \
   external-secrets/external-secrets \
    -n external-secrets \
    --create-namespace

Give it a minute to figure itself out, and when you are done you should have a total of 12 pods or so across 3 deployments in namespace "external-secrets", here is our view from Headlamp (so far).

image.png

Provision a SecretStore

So the custom resource provided by external-secrets-operator, the SecretStore has a direct communication line to talk to Google Cloud External Secrets.  For this I created a service account, scoped with Secret Manager Admin, and created a key for the SecretStore to use.

kubectl -n ikoplus create secret generic gcp-sm-credentials   --from-file=secret-access-credentials=ikoplus-293eb407499d.json

Apply the below, its commented enough to just fill it out like a form:

# gcpsm-secretstore.yaml
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: gcp-sm-store
  namespace: ikoplus
spec:
  provider:
    gcpsm:
      projectID: ikoplus
      auth:
        secretRef:
          secretAccessKeySecretRef:
            name: gcp-sm-credentials
            key: secret-access-credentials
kubectl apply -f secretstore.yaml --kubeconfig ikoplus-eso.kubeconfig

Create ExternalSecret

Now, link the ExternalSecret to a plain 'ol Kubernetes secret.

# externalsecret-dockerconfig.yaml
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: external-containers-pull-secret # I like to just prepend "external"
  namespace: ikoplus
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: gcp-sm-store
    kind: SecretStore
  target:
    name: containers-pull-secret        # Name of the Kubernetes Secret to create
    creationPolicy: Owner
    template:
      type: kubernetes.io/dockerconfigjson
      data:
        # "dockerconfig" is the logical key we use inside the template
        .dockerconfigjson: "{{ .dockerconfig | toString }}"
  data:
    - secretKey: dockerconfig     # This name is used in the template above
      remoteRef:
        key: ikoplus-eso-gcp      # The secret ID in Google Secret Manager
kubectl apply -f externalsecret.yaml --kubeconfig ikoplus-eso.kubeconfig

Using the external-secrets-operator plugin for Headlamp, you can see our Custom resources for ESO created.

Attestation

Lets deploy the IKO Helm Chart with the updated values for the image pull secret... this should point to the standard Kubernetes secret we created, which resolves to an external secret in Google Cloud Platform.
 

## Optionally specify an array of imagePullSecrets.
## Secrets must be manually created in the namespace.
## ref: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod
##
imagePullSecrets:
  - name: containers-pull-secret    #### actually from external-containers-pull-secret
## Specify a imagePullPolicy
## ref: http://kubernetes.io/docs/user-guide/images/#pre-pulling-images
##

 
Successful Pull!! Uses containers-pull-secret which is actually external-containers-pull-secret in Google Cloud Platform Secrets Manager!

 

External Secrets Operator is an OpenCollective org, give them a look for your IrisCluster workloads.

🎉

Now you have somehwere to stash that password hash!

Discussão (0)1
Entre ou crie uma conta para continuar
Anúncio
· 4 hr atrás

[Vídeo] Arquitetando para o Sucesso com Espelhamento (Mirroring)

Olá, Comunidade!

Você busca maneiras de fortalecer a implementação da sua plataforma de dados InterSystems IRIS®? Veja como o espelhamento pode ajudar:

Arquitetando para o Sucesso com Espelhamento

Neste vídeo, você aprenderá estratégias para configurar o espelhamento que atendam às necessidades da sua empresa, considerando os custos. Explore as melhores práticas para planejar, testar e proteger sua configuração, para que você possa manter a alta disponibilidade mesmo durante falhas.

Discussão (0)1
Entre ou crie uma conta para continuar
Anúncio
· 7 hr atrás

[Video] Operações e escalabilidade com InterSystems IRIS - Do Zero ao Sucesso

Olá Comunidade,

Confira o novo vídeo no canal do YouTube da InterSystems Developers:

⏯ Operações e escalabilidade com InterSystems IRIS - Do Zero ao Sucesso @ Ready 2025 

Nesta sessão introdutória, aprenda como o InterSystems IRIS ajuda você a levar seu aplicativo de negócios do desenvolvimento para um ambiente altamente disponível, escalável e de fácil manutenção com o mínimo de esforço. Destacaremos os avanços recentes e os recursos futuros que reduzem significativamente a complexidade da configuração, além de uma visão geral do que está por vir para os produtos e serviços em nuvem da InterSystems.

Apresentadores:
🗣 @Bob Kuszewski, Product Manager, Developer Experience at InterSystems
🗣 @Benjamin De Boe, Lead Product Manager Data & Analytics at InterSystems

Quer aprimorar suas habilidades? Assista agora e inscreva-se para receber dicas futuras!

Discussão (0)1
Entre ou crie uma conta para continuar
Artigo
· 9 hr atrás 3min de leitura

Cómo podéis probar gj :: configExplorer de forma independiente en Windows

En mi artículo anterior en el que presentaba gj :: configExplorer señalé cómo un aparente error en los elementos de Windows de la API nativa para Node.js hace que actualmente no sea posible ejecutarlo en VS Code en un escritorio Windows. En un comentario a ese artículo ofrecí una solución alternativa, pero esta requiere un host Linux con Docker al que podáis conectaros por SSH.

Si no tenéis un destino adecuado, ahora es posible aprovechar vuestro Docker Desktop local de Windows. Aquí os explico cómo:

  1. Abrid una nueva ventana de VS Code.

Los pasos originales del 2 al 9 pueden simplificarse ejecutando “Dev Containers: Clone Repository in Container Volume...” desde la Paleta de Comandos e introduciendo “https://github.com/gjsjohnmurray/gjConfigExplorer.git” cuando se os pida.

  1. Id a la vista de Control de Código Fuente haciendo clic en su icono en la Barra de Actividades.
  2. Haced clic en el botón “Clone Repository”.
  3. Pegad https://github.com/gjsjohnmurray/gjConfigExplorer.git en el mensaje del centro superior y pulsad Enter.
  4. Elegid una carpeta en la que crear la carpeta del clon.
  5. Cuando se os pida, abrid el repositorio clonado.
  6. Confiad en el autor si se os solicita.
  7. Buscad una notificación (abajo a la derecha):
  8. Haced clic en “Reopen in Container”. Este paso puede tardar unos minutos en completarse.

El contenedor ejecuta una instancia de Linux que a su vez contiene Docker, una técnica llamada “Docker en Docker”.

  1. Cerrad la notificación sobre las extensiones recomendadas.
  2. Esperad hasta que finalice la actividad del postCreateCommand del archivo devcontainer.json.
  3. Cambiaos a la vista de Ejecución y Depuración y haced clic en el botón “play”. O simplemente pulsad F5.
  4. Cuando se abra la ventana del Extension Development Host (EDH), cerrad la notificación sobre la imposibilidad de conectarse a “iris”.
  5. En la vista del Explorador, haced clic con el botón derecho en el archivo docker-compose.yml y elegid “Compose Up”.
  6. Esperad unos minutos a que se descargue la imagen intersystemsdc/iris-community:latest en el Docker interno (el que se ejecuta en Linux).
  7. Esto proporcionará un contenedor IRIS cuya configuración gj :: configExplorer explorará.
  8. Cuando la salida del terminal indique que el contenedor test-iris-1 se ha iniciado, haced clic en el panel de la barra de estado iris[USER] y, en el mensaje del centro superior, elegid “Toggle Connection”.

Ahora, haced click aquí. 

Esperad a que Structurizr Lite se inicie en otro contenedor dentro de vuestro contenedor de Linux.

Una vez que Structurizr Lite se haya iniciado, deberíais ver que se abre una nueva pestaña en vuestro navegador web. Es posible que la página aparezca en blanco al principio mientras se descargan los recursos, pero pronto deberíais ver lo siguiente:

Al hacer clic en la segunda miniatura aparece lo siguiente:

La instancia “iris” está configurada con dos conexiones de servidor de datos ECP. Estas son falsas porque la licencia de la edición Community de IRIS no incluye la función ECP, pero, por suerte, esta restricción no nos impide definir las conexiones.

Haced clic en la tercera miniatura para obtener lo siguiente:

Luego utilizad su botón de Zoom (abajo a la derecha) junto con el desplazador horizontal para ver lo siguiente:

 

Si os gusta lo que estáis viendo, apoyad esta extensión votando por ella en el concurso actual de DC. La votación termina el domingo 12 de octubre a medianoche, hora del este de Estados Unidos.

Discussão (0)1
Entre ou crie uma conta para continuar