Como implantar um cluster do gerenciador de filas do IBM MQ de alta disponibilidade no Compute Engine com o GlusterFS

Neste tutorial, explicamos o processo de implantação de um cluster do gerenciador de filas do IBM MQ de alta disponibilidade usando o Compute Engine no Google Cloud. O MQ transporta dados entre esses pontos por meio de um sistema de filas, garantindo a entrega em caso de falha da rede ou do aplicativo.

Este tutorial é útil se você trabalha com arquitetura corporativa, administração de sistemas, desenvolvimento ou engenharia de DevOps e quer implantar um cluster do gerenciador de filas do IBM MQ altamente disponível no Google Cloud.

Neste tutorial, presumimos que você esteja familiarizado com:

  • Servidor Ubuntu 16.04
  • IBM MQ
  • Compute Engine
  • Balanceamento de carga de serviços de rede

Objetivos

  • Criar as instâncias do Compute Engine.
  • Criar as regras de firewall.
  • Criar os balanceadores de carga internos.
  • Configurar o sistema de arquivos compartilhados do GlusterFS.
  • Configurar cada nó do cluster.
  • Configurar o cluster para alta disponibilidade.
  • Testar o cluster.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • Compute Engine
  • Rede

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Antes de começar

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. Ative a Compute Engine API.

    Ative a API

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Veja mais detalhes em Como fazer a limpeza.

Arquitetura

Para criar uma implantação altamente disponível e escalonável do IBM MQ, esta solução combina clusters de gerenciador de filas com gerenciadores de filas de várias instâncias. Os gerenciadores de filas de várias instâncias são executados em uma configuração ativa/de espera, utilizando um volume compartilhado para distribuir dados de estado e configuração. Os gerenciadores de filas em cluster compartilham informações de configuração por meio de um canal de rede e podem executar o balanceamento de carga de mensagens recebidas. No entanto, o estado da mensagem não é compartilhado entre os dois gerenciadores de filas.

Usando os dois modelos de implantação, é possível conseguir redundância no nível do gerenciador de filas e, em seguida, dimensionar com a distribuição da carga entre um ou mais gerenciadores de filas.

Neste tutorial, são criados dois gerenciadores de filas denominados A e B. Para cada gerenciador de filas, é possível criar um nó principal e um nó de espera (mq-1 e mq-2 para o gerenciador de filas A e mq-3 e mq-4 para o gerenciador de filas B). Para transmitir o tráfego às instâncias principais, use um balanceador de carga interno para cada gerenciador de filas. Os consumidores e editores são direcionados para os endereços do balanceador de carga como se fossem os endereços diretos dos gerenciadores de filas. Os gerenciadores de filas também se comunicam entre si por meio dos balanceadores de carga internos.

Os gerenciadores de filas de várias instâncias do IBM MQ exigem armazenamento compartilhado. Neste tutorial, use o GlusterFS, um sistema de arquivos distribuído e escalonável, como um sistema de arquivos compartilhado entre os nós de cada gerenciador de filas de várias instâncias.

Arquitetura do sistema de várias instâncias do MQ

Como criar as instâncias do Compute Engine

Crie agora os recursos de computação necessários para este tutorial. As instâncias do Compute Engine mq-1 e mq-2 serão os nós principal e de espera do gerenciador de filas A, enquanto mq-3 e mq-4 serão os nós principal e de espera do gerenciador de filas B. Você também cria grupos de instâncias não gerenciadas para cada instância, porque elas estão em zonas diferentes. Posteriormente, conecte os grupos de instâncias não gerenciadas ao balanceador de carga.

  1. Abra o Cloud Shell.

    ACESSAR o Cloud Shell

  2. Crie um script de inicialização para as instâncias de computação do MQ:

    cat << 'EOF' >  mqstartup.sh
    #!/bin/bash
    
    if [ -f /root/INSTALLATION_DONE ]; then
      echo "Skipping because installation completed."
      exit 0
    fi
    
    # Docker installation
    
    apt-get install -y apt-transport-https ca-certificates curl software-properties-common
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
    add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
    apt-get update
    apt-get install -y docker-ce
    
    # GlusterFS installation
    
    apt-get install -y glusterfs-server
    
    # Format and mount the persistent disk
    
    mkdir -p /data
    mkfs.ext4 -m 0 -F -E lazy_itable_init=0,lazy_journal_init=0,discard /dev/sdb
    mount -o discard,defaults /dev/sdb /data
    
    touch /root/INSTALLATION_DONE
    EOF
    
  3. Crie uma instância do Compute Engine para o nó principal do gerenciador de filas A:

    gcloud compute instances create mq-1 \
        --zone=us-central1-c \
        --machine-type=n1-standard-1 \
        --image-family=ubuntu-1604-lts \
        --image-project=ubuntu-os-cloud \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-standard \
        --boot-disk-device-name=mq-1 \
        --create-disk=mode=rw,size=10,type=projects/${DEVSHELL_PROJECT_ID}/zones/us-central1-c/diskTypes/pd-ssd,name=gluster-disk-1 \
        --tags=ibmmq \
        --metadata-from-file startup-script=mqstartup.sh
    
  4. Crie um grupo de instâncias não gerenciadas e inclua a instância:

    gcloud compute instance-groups unmanaged create mq-group-1 \
        --zone=us-central1-c
    
    gcloud compute instance-groups unmanaged add-instances mq-group-1 \
        --zone=us-central1-c \
        --instances=mq-1
    
  5. Crie uma instância do Compute Engine para o nó de espera do gerenciador de filas A:

    gcloud compute instances create mq-2 \
        --zone=us-central1-b \
        --machine-type=n1-standard-1 \
        --image-family=ubuntu-1604-lts \
        --image-project=ubuntu-os-cloud \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-standard \
        --boot-disk-device-name=mq-2 \
        --create-disk=mode=rw,size=10,type=projects/${DEVSHELL_PROJECT_ID}/zones/us-central1-b/diskTypes/pd-ssd,name=gluster-disk-2 \
        --tags=ibmmq \
        --metadata-from-file startup-script=mqstartup.sh
    
  6. Crie um grupo de instâncias não gerenciadas e inclua a instância:

    gcloud compute instance-groups unmanaged create mq-group-2 \
        --zone=us-central1-b
    
    gcloud compute instance-groups unmanaged add-instances mq-group-2 \
        --zone=us-central1-b \
        --instances=mq-2
    
  7. Crie uma instância do Compute Engine para o nó principal do gerenciador de filas B:

    gcloud compute instances create mq-3 \
        --zone=us-central1-a \
        --machine-type=n1-standard-1 \
        --image-family=ubuntu-1604-lts \
        --image-project=ubuntu-os-cloud \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-standard \
        --boot-disk-device-name=mq-3 \
        --create-disk=mode=rw,size=10,type=projects/${DEVSHELL_PROJECT_ID}/zones/us-central1-a/diskTypes/pd-ssd,name=gluster-disk-3 \
        --tags=ibmmq \
        --metadata-from-file startup-script=mqstartup.sh
    
  8. Crie um grupo de instâncias não gerenciadas e inclua a instância:

    gcloud compute instance-groups unmanaged create mq-group-3 \
        --zone=us-central1-a
    
    gcloud compute instance-groups unmanaged add-instances mq-group-3 \
        --zone=us-central1-a \
        --instances=mq-3
    
  9. Crie uma instância do Compute Engine para o nó de espera do gerenciador de filas B:

    gcloud compute instances create mq-4 \
        --zone=us-central1-f \
        --machine-type=n1-standard-1 \
        --image-family=ubuntu-1604-lts \
        --image-project=ubuntu-os-cloud \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-standard \
        --boot-disk-device-name=mq-4 \
        --create-disk=mode=rw,size=10,type=projects/${DEVSHELL_PROJECT_ID}/zones/us-central1-f/diskTypes/pd-ssd,name=gluster-disk-4 \
        --tags=ibmmq \
        --metadata-from-file startup-script=mqstartup.sh
    
  10. Crie um grupo de instâncias não gerenciadas e inclua a instância:

    gcloud compute instance-groups unmanaged create mq-group-4 \
        --zone=us-central1-f
    
    gcloud compute instance-groups unmanaged add-instances mq-group-4 \
        --zone=us-central1-f \
        --instances=mq-4
    

Como criar as regras de firewall

Para que os nós no cluster se comuniquem entre si e recebam tráfego do balanceador de carga, é necessário criar as regras de firewall apropriadas.

  1. Crie uma regra de firewall para permitir o tráfego entre os nós do cluster:

    gcloud compute firewall-rules create ibmmq-transport \
        --allow=tcp:1414 \
        --target-tags ibmmq \
        --source-tags ibmmq
    
  2. Crie uma regra de firewall para permitir o tráfego dos verificadores de integridade para os gerenciadores de filas:

    gcloud compute firewall-rules create fw-allow-health-checks \
        --allow=tcp:1414 \
        --target-tags ibmmq \
        --source-ranges 35.191.0.0/16,130.211.0.0/22
    

Como configurar o balanceador de carga TCP interno

Crie o balanceador de carga interno que monitora as quatro instâncias para determinar as duas instâncias principais em estado íntegro e transmitir o tráfego para elas.

  1. Crie a verificação de integridade:

    gcloud compute health-checks create tcp hc-tcp-1414 \
        --description="Health check: TCP 1414" \
        --check-interval=2s \
        --timeout=2s \
        --healthy-threshold=2 \
        --unhealthy-threshold=2 \
        --port=1414
    
  2. Crie os serviços de back-end:

    gcloud compute backend-services create mqm-svc-a \
        --load-balancing-scheme internal \
        --region us-central1 \
        --health-checks hc-tcp-1414 \
        --protocol tcp
    
    gcloud compute backend-services create mqm-svc-b \
        --load-balancing-scheme internal \
        --region us-central1 \
        --health-checks hc-tcp-1414 \
        --protocol tcp
    
  3. Adicione os grupos de instâncias não gerenciadas aos serviços de back-end:

    gcloud compute backend-services add-backend mqm-svc-a \
        --instance-group mq-group-1 \
        --instance-group-zone us-central1-c \
        --region us-central1
    
    gcloud compute backend-services add-backend mqm-svc-a \
        --instance-group mq-group-2 \
        --instance-group-zone us-central1-b \
        --region us-central1
    
    gcloud compute backend-services add-backend mqm-svc-b \
        --instance-group mq-group-3 \
        --instance-group-zone us-central1-a \
        --region us-central1
    
    gcloud compute backend-services add-backend mqm-svc-b \
        --instance-group mq-group-4 \
        --instance-group-zone us-central1-f \
        --region us-central1
    
  4. Crie a regra de encaminhamento:

    gcloud compute forwarding-rules create mqm-svc-a-forwarding-rule \
        --load-balancing-scheme internal \
        --ports 1414 --network default \
        --address 10.128.0.100 \
        --region us-central1 \
        --backend-service mqm-svc-a
    
    gcloud compute forwarding-rules create mqm-svc-b-forwarding-rule \
        --load-balancing-scheme internal \
        --ports 1414 \
        --network default \
        --address 10.128.0.101 \
        --region us-central1 \
        --backend-service mqm-svc-b
    

Como criar e ativar o volume do GlusterFS para o gerenciador de filas A

Neste tutorial, será utilizado o sistema de arquivos distribuído do GlusterFS como o armazenamento compartilhado entre os nós de um gerenciador de filas. Agora, para configurar o GlusterFS para o gerenciador de filas A, basta implantá-lo nas instâncias mq-1 e mq-2.

  1. Inicialize o pool confiável do GlusterFS no mq-1 por meio da sondagem de mq-2:

    gcloud compute ssh mq-1 \
        --zone=us-central1-c \
        --command='sudo mkdir -p /data/gv0 && sudo gluster peer probe mq-2' \
        -- -t
    
  2. Inicialize o pool confiável do GlusterFS no mq-2 por meio da sondagem de mq-1:

    gcloud compute ssh mq-2 \
        --zone=us-central1-b \
        --command='sudo mkdir -p /data/gv0 && sudo gluster peer probe mq-1' \
        -- -t
    
  3. Inicie a replicação do GlusterFS:

    gcloud compute ssh mq-2 \
        --zone=us-central1-b \
        --command='sudo gluster volume create mq-data replica 2 mq-1:/data/gv0 mq-2:/data/gv0 && sudo gluster volume start mq-data' \
        -- -t
    
  4. Ative o volume compartilhado em mq-2:

    gcloud compute ssh mq-2 \
        --zone=us-central1-b \
        --command='sudo mkdir -p /mnt/mqm_glusterfs && sudo mount -t glusterfs mq-1:/mq-data /mnt/mqm_glusterfs' \
        -- -t
    
  5. Ative o volume compartilhado em mq-1:

    gcloud compute ssh mq-1 \
        --zone=us-central1-c \
        --command='sudo mkdir -p /mnt/mqm_glusterfs && sudo mount -t glusterfs mq-1:/mq-data /mnt/mqm_glusterfs' \
        -- -t
    
  6. Verifique o status do volume compartilhado:

    gcloud compute ssh mq-1 \
        --zone=us-central1-c \
        --command='sudo gluster volume info'
    

    Exceto pelo código do volume, a saída é semelhante à seguinte:

    Volume Name: mq-data
    Type: Replicate
    Volume ID: ad63f6df-8469-4f30-9282-5a285d1a2b87
    Status: Started
    Number of Bricks: 1 x 2 = 2
    Transport-type: tcp
    Bricks:
    Brick1: mq-1:/data/gv0
    Brick2: mq-2:/data/gv0
    Options Reconfigured:
    performance.readdir-ahead: on
    

Como criar e ativar o volume do GlusterFS para o gerenciador de filas B

Agora, para configurar o GlusterFS para o gerenciador de filas B, basta implantá-lo nas instâncias mq-3 e mq-4.

  1. Inicialize o pool confiável do GlusterFS no mq-3 por meio da sondagem de mq-4:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command='sudo mkdir -p /data/gv0 && sudo gluster peer probe mq-4' \
        -- -t
    
  2. Inicialize o pool confiável do GlusterFS no mq-4 por meio da sondagem de mq-3:

    gcloud compute ssh mq-4 \
        --zone=us-central1-f \
        --command='sudo mkdir -p /data/gv0 && sudo gluster peer probe mq-3' \
        -- -t
    
  3. Inicie a replicação do GlusterFS:

    gcloud compute ssh mq-4 \
        --zone=us-central1-f \
        --command='sudo gluster volume create mq-data replica 2 mq-3:/data/gv0 mq-4:/data/gv0 && sudo gluster volume start mq-data' \
        -- -t
    
  4. Ative o volume compartilhado em mq-4:

    gcloud compute ssh mq-4 \
        --zone=us-central1-f \
        --command='sudo mkdir -p /mnt/mqm_glusterfs && sudo mount -t glusterfs mq-3:/mq-data /mnt/mqm_glusterfs' \
        -- -t
    
  5. Ative o volume compartilhado em mq-3:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command='sudo mkdir -p /mnt/mqm_glusterfs && sudo mount -t glusterfs mq-3:/mq-data /mnt/mqm_glusterfs' \
        -- -t
    
  6. Verifique o status do volume compartilhado:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command='sudo gluster volume info'
    

    Exceto pelo código do volume, você verá a seguinte saída:

    Volume Name: mq-data
    Type: Replicate
    Volume ID: ad63f6df-8469-4f30-9282-5a285d1a2b87
    Status: Started
    Number of Bricks: 1 x 2 = 2
    Transport-type: tcp
    Bricks:
    Brick1: mq-3:/data/gv0
    Brick2: mq-4:/data/gv0
    Options Reconfigured:
    performance.readdir-ahead: on
    

Inicializar o gerenciador de filas A

Agora, você executará uma série de comandos em mq-1 que definem o nome do gerenciador de filas, o armazenamento compartilhado, os canais de comunicação de entrada e saída, a autenticação e o outro gerenciador de filas no cluster.

  1. No Cloud Shell, execute um contêiner MQ temporário em mq-1 e se conecte a ele:

    gcloud compute ssh mq-1 \
        --zone=us-central1-c \
        --command='sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=A --volume /mnt/mqm_glusterfs:/mnt/mqm --network host --name=ibmmq-init --rm=true  ibmcom/mq:latest ' \
       -- -t
    
  2. Digite as definições de cluster e fila:

    mkdir -p /mnt/mqm/data
    chown mqm:mqm /mnt/mqm/data
    /opt/mqm/bin/crtmqdir -f -s
    su mqm -c "cp /etc/mqm/web/installations/Installation1/servers/mqweb/*.xml /var/mqm/web/installations/Installation1/servers/mqweb/"
    su mqm -c "crtmqm -q -p 1414 $MQ_QMGR_NAME"
    su mqm -c "strmqm -x"
    
  3. Configure o gerenciador de filas A para clustering:

    echo "
    * Define the full repository for the cluster
    ALTER QMGR REPOS(GCP)
    
    * Define backstop rule for channel auth
    SET CHLAUTH('*') TYPE(ADDRESSMAP) ADDRESS('*') USERSRC(NOACCESS) DESCR('Back-stop rule - Blocks everyone') ACTION(REPLACE)
    
    * Clustering channels and listeners
    DEFINE LISTENER(A_LS) TRPTYPE(TCP) CONTROL(QMGR)
    
    DEFINE CHANNEL(GCP.A) CHLTYPE(CLUSRCVR) CONNAME('10.128.0.100') CLUSTER(GCP) REPLACE
    DEFINE CHANNEL(GCP.B) CHLTYPE(CLUSSDR) CONNAME('10.128.0.101') CLUSTER(GCP) REPLACE
    
    SET CHLAUTH('GCP.A') TYPE (QMGRMAP) QMNAME(B) USERSRC(CHANNEL) ADDRESS('*')" | runmqsc $MQ_QMGR_NAME
    
  4. Configure a fila, o canal e a autorização do aplicativo:

    echo "
    * Application queues
    DEFINE QLOCAL('APP.QUEUE.1') DEFBIND(NOTFIXED) CLWLUSEQ(ANY) CLUSTER(GCP) REPLACE
    
    * Application topics
    DEFINE TOPIC('APP.BASE.TOPIC') TOPICSTR('app/') REPLACE
    
    * Application connection authentication
    DEFINE AUTHINFO('APP.AUTHINFO') AUTHTYPE(IDPWOS) CHCKCLNT(REQDADM) CHCKLOCL(OPTIONAL) ADOPTCTX(YES) REPLACE
    ALTER QMGR CONNAUTH('APP.AUTHINFO')
    REFRESH SECURITY(*) TYPE(CONNAUTH)
    
    * Application channels
    DEFINE CHANNEL('APP.SVRCONN') CHLTYPE(SVRCONN) MCAUSER('app') REPLACE
    SET CHLAUTH('APP.SVRCONN') TYPE(ADDRESSMAP) ADDRESS('*') USERSRC(CHANNEL) CHCKCLNT(REQUIRED) DESCR('Allows connection via APP channel') ACTION(REPLACE)
    
    * Application auth records
    SET AUTHREC GROUP('mqclient') OBJTYPE(QMGR) AUTHADD(CONNECT,INQ)
    SET AUTHREC PROFILE('APP.**') GROUP('mqclient') OBJTYPE(QUEUE) AUTHADD(BROWSE,GET,INQ,PUT)
    SET AUTHREC PROFILE('APP.**') GROUP('mqclient') OBJTYPE(TOPIC) AUTHADD(PUB,SUB)" | runmqsc $MQ_QMGR_NAME
    
    exit
    

Inicializar o gerenciador de filas B

Agora, você executará uma série de comandos em mq-3 que definem as mesmas informações para o segundo gerenciador de filas: o nome do gerenciador de filas, o armazenamento compartilhado, os canais de comunicação de entrada e saída, a autenticação e o outro gerenciador de filas no cluster.

  1. No Cloud Shell, execute um contêiner MQ temporário em mq-3 e se conecte a ele:

    gcloud compute ssh  mq-3 \
        --zone=us-central1-a \
        --command='sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=B --volume /mnt/mqm_glusterfs:/mnt/mqm --network host --name=ibmmq-init --rm=true ibmcom/mq:latest' \
        -- -t
    
  2. Digite as definições de cluster e fila. Esta é uma versão consolidada das etapas 2 a 4 do procedimento que você executou para o gerenciador de filas A.

    mkdir -p /mnt/mqm/data
    chown mqm:mqm /mnt/mqm/data
    /opt/mqm/bin/crtmqdir -f -s
    su mqm -c "cp /etc/mqm/web/installations/Installation1/servers/mqweb/*.xml /var/mqm/web/installations/Installation1/servers/mqweb/"
    su mqm -c "crtmqm -q -p 1414 $MQ_QMGR_NAME"
    su mqm -c "strmqm -x"
    
    echo "
    * Define the full repository for the cluster
    ALTER QMGR REPOS(GCP)
    
    * Define backstop rule for channel auth
    SET CHLAUTH('*') TYPE(ADDRESSMAP) ADDRESS('*') USERSRC(NOACCESS) DESCR('Back-stop rule - Blocks everyone') ACTION(REPLACE)
    
    * Clustering channels and listeners
    DEFINE LISTENER(B_LS) TRPTYPE(TCP) CONTROL(QMGR)
    
    DEFINE CHANNEL(GCP.B) CHLTYPE(CLUSRCVR) CONNAME('10.128.0.101') CLUSTER(GCP) REPLACE
    DEFINE CHANNEL(GCP.A) CHLTYPE(CLUSSDR) CONNAME('10.128.0.100') CLUSTER(GCP) REPLACE
    
    SET CHLAUTH('GCP.B') TYPE (QMGRMAP) QMNAME(A) USERSRC(CHANNEL) ADDRESS('*')
    
    * Application queues
    DEFINE QLOCAL('APP.QUEUE.1') DEFBIND(NOTFIXED) CLWLUSEQ(ANY) CLUSTER(GCP) REPLACE
    
    * Application topics
    DEFINE TOPIC('APP.BASE.TOPIC') TOPICSTR('app/') REPLACE
    
    * Application connection authentication
    DEFINE AUTHINFO('APP.AUTHINFO') AUTHTYPE(IDPWOS) CHCKCLNT(REQDADM) CHCKLOCL(OPTIONAL) ADOPTCTX(YES) REPLACE
    ALTER QMGR CONNAUTH('APP.AUTHINFO')
    REFRESH SECURITY(*) TYPE(CONNAUTH)
    
    * Application channels
    DEFINE CHANNEL('APP.SVRCONN') CHLTYPE(SVRCONN) MCAUSER('app') REPLACE
    SET CHLAUTH('APP.SVRCONN') TYPE(ADDRESSMAP) ADDRESS('*') USERSRC(CHANNEL) CHCKCLNT(REQUIRED) DESCR('Allows connection via APP channel') ACTION(REPLACE)
    
    * Application auth records
    SET AUTHREC GROUP('mqclient') OBJTYPE(QMGR) AUTHADD(CONNECT,INQ)
    SET AUTHREC PROFILE('APP.**') GROUP('mqclient') OBJTYPE(QUEUE) AUTHADD(BROWSE,GET,INQ,PUT)
    SET AUTHREC PROFILE('APP.**') GROUP('mqclient') OBJTYPE(TOPIC) AUTHADD(PUB,SUB)" | runmqsc $MQ_QMGR_NAME
    
    exit
    

Como iniciar o IBM MQ no modo HA

Agora que os gerenciadores de filas foram inicializados, inicie o cluster do IBM MQ.

  1. No Cloud Shell, inicie o gerenciador de filas A em mq-1:

    gcloud compute ssh  mq-1  \
        --zone=us-central1-c \
        --command="sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=A  --volume /mnt/mqm_glusterfs:/mnt/mqm --publish 1414:1414 --network host --name=ibmmq-node --rm=true -d ibmcom/mq:latest -c 'echo app:APPPass1! | chpasswd && su mqm -c \"strmqm -x\"; tail -f /dev/null'"
    

    Para o propósito deste tutorial, neste comando, defina AppPass1! como a senha do aplicativo do usuário.

  2. Inicialize o gerenciador de filas A em mq-2:

    gcloud compute ssh  mq-2  \
        --zone=us-central1-b \
        --command="sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=A --volume /mnt/mqm_glusterfs:/mnt/mqm --publish 1414:1414 --network host --name=ibmmq-node --rm=true -d ibmcom/mq:latest -c 'echo app:APPPass1! | chpasswd && su mqm -c \"strmqm -x\"; tail -f /dev/null'"
    

    Neste comando, defina AppPass1! como a senha do aplicativo do usuário.

  3. Para verificar o status do seu balanceador de carga, acesse a página Balanceamento de carga no Console do Cloud.

    ABRIR A PÁGINA "BALANCEAMENTO DE CARGA"

  4. Na lista, selecione o balanceador de carga mqm-svc-a.

    Página do Console para balanceadores de carga, mostrando mq-group1 e mq-group2

    Quando o balanceador de carga mqm-svc-a mostrar que tem um grupo de instâncias em estado íntegro (como exibido na captura de tela acima), você estará pronto para avançar para a próxima etapa.

  5. No Cloud Shell, inicie o gerenciador de filas B em mq-3:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command="sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=B --volume /mnt/mqm_glusterfs:/mnt/mqm --publish 1414:1414 --network host --name=ibmmq-node --rm=true -d ibmcom/mq:latest -c 'echo app:APPPass1! | chpasswd && su mqm -c \"strmqm -x\"; tail -f /dev/null'"
    
  6. Inicie o gerenciador de filas B em mq-4:

    gcloud compute ssh mq-4 \
        --zone=us-central1-f \
        --command="sudo docker run -it --entrypoint=/bin/bash --env LICENSE=accept --env MQ_QMGR_NAME=B --volume /mnt/mqm_glusterfs:/mnt/mqm --publish 1414:1414 --network host --name=ibmmq-node --rm=true -d ibmcom/mq:latest -c 'echo app:APPPass1! | chpasswd && su mqm -c \"strmqm -x\"; tail -f /dev/null'"
    

Como verificar o cluster

Antes de testar a implantação, é necessário verificar se os gerenciadores de filas A e B estão se comunicando corretamente.

  1. No Cloud Shell, conecte-se ao contêiner do IBM MQ em mq-3:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command="sudo docker exec -it ibmmq-node /bin/bash" \
        -- -t
    
  2. Verifique o status dos canais de comunicação do cluster:

    echo "DISPLAY CHSTATUS(*)" | runmqsc $MQ_QMGR_NAME && exit
    

    Se tudo estiver funcionando corretamente, a saída será exibida assim:

    5724-H72 (C) Copyright IBM Corp. 1994, 2018.
    Starting MQSC for queue manager B.
    
         1 : display chstatus(*)
    AMQ8417I: Display Channel Status details.
       CHANNEL(GCP.B)                          CHLTYPE(CLUSRCVR)
       CONNAME(10.128.0.2)                     CURRENT
       RQMNAME(A)                              STATUS(RUNNING)
       SUBSTATE(RECEIVE)
    AMQ8417I: Display Channel Status details.
       CHANNEL(GCP.A)                          CHLTYPE(CLUSSDR)
       CONNAME(10.128.0.100(1414))             CURRENT
       RQMNAME(A)                              STATUS(RUNNING)
       SUBSTATE(MQGET)           XMITQ(SYSTEM.CLUSTER.TRANSMIT.QUEUE)
    One MQSC command read.
    No commands have a syntax error.
    All valid MQSC commands were processed.
    

Como enviar mensagens para o cluster

Para testar o cluster, envie duas mensagens para uma fila denominada APP.QUEUE.1 usando um aplicativo de amostra fornecido pela IBM na imagem do Docker.

Enviar mensagens de teste para o gerenciador de filas B

  1. No Cloud Shell, conecte-se ao contêiner do IBM MQ em mq-3:

    gcloud compute ssh mq-3 \
        --zone=us-central1-a \
        --command="sudo docker exec -it ibmmq-node /bin/bash" \
        -- -t
    
  2. No shell do terminal, conecte-se ao gerenciador de filas B para iniciar o aplicativo que envia a mensagem:

    MQSAMP_USER_ID=app /opt/mqm/samp/bin/amqsput APP.QUEUE.1 B
    
  3. Quando solicitado, faça a autenticação inserindo a senha do aplicativo que você criou anteriormente (neste tutorial, ela é APPPass1!).

  4. Quando aparecer isto: a fila de destino é APP.QUEUE.1, envie uma mensagem de teste para a fila inserindo abcdef.

  5. Digite 123456 para enviar outra mensagem de teste.

  6. Pressione Enter para sair do aplicativo que envia a mensagem.

    A saída tem esta aparência:

    Sample AMQSPUT0 start
    Enter password: *********
    target queue is APP.QUEUE.1
    abcdef
    123456
    
    Sample AMQSPUT0 end
    
  7. Verifique se há uma mensagem sendo transmitida no gerenciador de filas B:

    echo "display qstatus(APP.QUEUE.1)" | runmqsc $MQ_QMGR_NAME | grep CURDEPTH
    

    Há apenas uma mensagem sendo transmitida, porque o balanceamento de carga do IBM MQ transmitiu a outra mensagem para o gerenciador de filas A, conforme será descrito posteriormente.

  8. Feche a conexão SSH:

    exit
    

    A saída a seguir será exibida.

    CURDEPTH(1)                             IPPROCS(0)
    

    O gerenciador de filas B tem uma mensagem sendo transmitida, embora na etapa anterior você tenha enviado duas mensagens. Isso ocorre porque o IBM MQ balanceia a carga das mensagens entre os gerenciadores de filas e a segunda mensagem foi enviada para o gerenciador de filas A.

Verificar mensagens sendo transmitidas no gerenciador de filas A

  1. No Cloud Shell, conecte-se ao contêiner do IBM MQ em mq-1:

    gcloud compute ssh mq-1 \
        --zone=us-central1-c \
        --command="sudo docker exec -it ibmmq-node /bin/bash" \
        -- -t
    
  2. Na janela do terminal, verifique se há uma mensagem sendo transmitida no gerenciador de filas A:

    echo "display qstatus(APP.QUEUE.1)" | runmqsc $MQ_QMGR_NAME | grep CURDEPTH
    

    A saída a seguir será exibida.

    CURDEPTH(1)                             IPPROCS(0)
    

Como testar a alta disponibilidade de gerenciador de filas

Encerre a instância mq-3 e verifique se mq-4 se torna a instância principal do gerenciador de filas B.

  1. No Cloud Shell, interrompa a instância mq-3:

    gcloud compute instances stop mq-3 \
        --zone=us-central1-a
    
  2. Confirme se mq-4 agora é a instância principal. Para isso, verifique se ela está em estado íntegro na perspectiva do balanceador de carga:

    gcloud compute backend-services get-health mqm-svc-b \
        --region=us-central1
    

    A saída será exibida assim:

    backend: https://www.googleapis.com/compute/v1/projects/ibmmq1/zones/us-central1-a/instanceGroups/mq-group-3
    status:
          kind: compute#backendServiceGroupHealth---backend: https://www.googleapis.com/compute/v1/projects/ibmmq1/zones/us-central1-f/instanceGroups/mq-group-4
    status:
          healthStatus:
        - healthState: HEALTHY
        instance: https://www.googleapis.com/compute/v1/projects/ibmmq1/zones/us-central1-f/instances/mq-4
        ipAddress: 10.128.0.5
        port: 80
        kind: compute#backendServiceGroupHealth
    

Como mover para a produção

Neste tutorial, você usou o IBM MQ Advanced for Developers. Antes de avançar para a produção, veja outros conjuntos de licenciamento e recursos disponíveis. Consulte também a documentação da IBM sobre como executar o IBM MQ em um contêiner antes de enviá-lo para produção.

Como fazer a limpeza

Após a conclusão deste tutorial, será possível limpar os recursos criados no Google Cloud para que eles não consumam sua cota e você não receba cobranças por eles no futuro. Veja como excluir e desativar esses recursos nas seções a seguir.

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir