Implementar un clúster de administradores de colas de IBM MQ con alta disponibilidad en Compute Engine mediante GlusterFS

En este instructivo, se explica cómo implementar un clúster de administradores de colas de IBM MQ con alta disponibilidad mediante Compute Engine en Google Cloud. MQ transporta datos entre estos puntos a través de un sistema de colas que garantiza la entrega en caso de fallas de la red o la aplicación.

Este instructivo es útil si trabajas en la arquitectura empresarial, la administración de sistemas, el desarrollo o la ingeniería de devops, y deseas implementar un clúster de administradores de colas de IBM MQ con alta disponibilidad en Google Cloud.

En este instructivo, suponemos que ya sabes usar los siguientes sistemas:

• Ubuntu server 16.04
• IBM MQ
• Compute Engine
• Balanceo de cargas de servicios de red

Objetivos

• Crear las instancias de Compute Engine
• Crear las reglas de firewall
• Crear los balanceadores de cargas internos
• Configurar el sistema de archivos compartidos de GlusterFS
• Configurar cada nodo del clúster
• Configurar el clúster para alta disponibilidad
• Probar el clúster

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen los siguientes:

• Compute Engine
• Redes

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

1. Accede a tu Cuenta de Google.

   Si todavía no tienes una cuenta, regístrate para obtener una nueva.

2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir a la página Selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

4. Habilita las Compute Engine API.

   Habilita la API

Cuando completes el instructivo puedes borrar los recursos que hayas creado para evitar que se te sigan facturando. Para obtener más detalles, consulta cómo realizar una limpieza.

Arquitectura

Para crear una implementación con alta disponibilidad y escalable de IBM MQ, esta solución combina clústeres de administradores de colas con administradores de colas de varias instancias. Los administradores de colas de varias instancias se ejecutan en una configuración activa/en espera, mediante un volumen compartido a fin de compartir los datos de estado y de configuración. Los administradores de colas agrupados en clústeres comparten información sobre la configuración mediante un canal de red y pueden realizar el balanceo de cargas de los mensajes entrantes. Sin embargo, el estado del mensaje no se comparte entre los dos administradores de colas.

Mediante el uso de ambos modelos de implementación, puedes lograr redundancia en el nivel del administrador de colas y, luego, escalar a través de la distribución de la carga entre uno o más administradores de colas.

En este instructivo, crearás dos administradores de colas, denominados A y B. En cada administrador de colas, debes crear un nodo principal y uno en espera (mq-1 y mq-2 para el administrador de colas A, y mq-3 y mq-4 para el B). A fin de enrutar el tráfico a las instancias principales, usa un balanceador de cargas interno para cada administrador de colas. Se dirige a los consumidores y los publicadores a las direcciones del balanceador de cargas como si esas fueran las direcciones directas de los administradores de colas. Los administradores de colas también se comunican entre sí a través de los balanceadores de cargas internos.

Los administradores de colas de varias instancias de IBM MQ requieren un almacenamiento compartido. En este instructivo, se usa GlusterFS, un sistema de archivos distribuido y escalable, como un sistema de archivos compartido entre los nodos de cada administrador de colas de varias instancias.

Crea las instancias de Compute Engine

Ahora crearás los recursos de procesamiento necesarios para este instructivo. Las instancias de Compute Engine mq-1 y mq-2 serán los nodos principales y en espera del administrador de colas A, y mq-3 y mq-4 serán los del B, respectivamente. También debes crear grupos de instancias no administrados para cada instancia, ya que se encuentran en diferentes zonas. Adjuntarás los grupos de instancias no administrados al balanceador de cargas más adelante.

1. Abre Cloud Shell.

   IR A Cloud Shell

2. Crea una secuencia de comandos de inicio para las instancias de procesamiento de 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. Crea una instancia de Compute Engine para el nodo principal del administrador de colas 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. Crea un grupo de instancias no administrado y agrega la instancia:

   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. Crea una instancia de Compute Engine para el nodo en espera del administrador de colas 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. Crea un grupo de instancias no administrado y agrega la instancia:

   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. Crea una instancia de Compute Engine para el nodo principal del administrador de colas 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. Crea un grupo de instancias no administrado y agrega la instancia:

   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. Crea una instancia de Compute Engine para el nodo en espera del administrador de colas 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. Crea un grupo de instancias no administrado y agrega la instancia:

    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
    

Cómo crear las reglas de firewall

Para que los nodos del clúster se comuniquen entre sí y reciban tráfico del balanceador de cargas, debes crear las reglas de firewall adecuadas.

1. Crea una regla de firewall para permitir el tráfico entre los nodos del clúster:

   gcloud compute firewall-rules create ibmmq-transport \
       --allow=tcp:1414 \
       --target-tags ibmmq \
       --source-tags ibmmq
   

2. Crea una regla de firewall para permitir el tráfico desde los verificadores de estado hacia los administradores de colas:

   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
   

Cómo configurar el balanceador de cargas TCP interno

Ahora crearás el balanceador de cargas interno que supervisa las cuatro instancias para determinar cuáles son las dos instancias principales que se encuentran en buen estado y dirigir el tráfico hacia estas.

1. Crea la verificación de estado:

   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. Crea los servicios de backend:

   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. Agrega los grupos de instancias no administrados a los servicios de backend:

   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. Crea la regla de reenvío:

   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
   

Cómo crear y activar el volumen de GlusterFS para el administrador de colas A

En este instructivo, se usa el sistema de archivos distribuido GlusterFS como almacenamiento compartido entre los nodos de un administrador de colas. Ahora configura GlusterFS para el administrador de colas A mediante su implementación en las instancias mq-1 y mq-2.

1. Inicializa el grupo de confianza de GlusterFS en mq-1 mediante un sondeo en 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. Inicializa el grupo de confianza de GlusterFS en mq-2 mediante un sondeo en 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. Inicia la replicación de 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. Activa el volumen compartido en 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. Activa el volumen compartido en 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. Verifica el estado del volumen compartido:

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

   Excepto por el ID de volumen, la salida luce de la siguiente manera:

   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
   

Cómo crear y activar el volumen de GlusterFS para el administrador de colas B

Ahora configura GlusterFS para el administrador de colas B mediante su implementación en las instancias mq-3 y mq-4.

1. Inicializa el grupo de confianza de GlusterFS en mq-3 mediante un sondeo en 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. Inicializa el grupo de confianza de GlusterFS en mq-4 mediante un sondeo en 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. Inicia la replicación de 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. Activa el volumen compartido en 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. Activa el volumen compartido en 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. Verifica el estado del volumen compartido:

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

   Con la excepción del ID de volumen, verás el siguiente resultado:

   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
   

Cómo inicializar el administrador de colas A

Ahora, debes ejecutar una serie de comandos en mq-1 que definen el nombre del administrador de colas, el almacenamiento compartido, los canales de comunicación entrantes y salientes, la autenticación y el otro administrador de colas en el clúster de administradores de colas.

1. En Cloud Shell, ejecuta un contenedor de MQ temporal en mq-1 y conéctate a él:

   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. Ingresa las definiciones de cola y clúster:

   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. Configura el administrador de colas A para la agrupación en clústeres:

   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. Configura la cola de la aplicación, el canal y la autorización:

   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
   

Cómo inicializar el administrador de colas B

Ahora, debes ejecutar una serie similar de comandos en mq-3 que definen la misma información para el segundo administrador de colas: nombre del administrador de colas, el almacenamiento compartido, los canales de comunicación entrantes y salientes, la autenticación y el otro administrador de colas en el clúster de administradores de colas.

1. En Cloud Shell, ejecuta un contenedor de MQ temporal en mq-3 y conéctate a él:

   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. Ingresa las definiciones de cola y clúster. (Esta es una versión consolidada de los pasos 2 a 4 del procedimiento que ejecutaste para el administrador de colas 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
   

Cómo iniciar IBM MQ en modo de alta disponibilidad

Ahora que has inicializado los administradores de colas, puedes iniciar el clúster de IBM MQ.

1. En Cloud Shell, inicia el administrador de colas A en 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'"
   

   A los fines de este instructivo, en este comando se establece AppPass1! como contraseña para la app de usuario.

2. Inicia el administrador de colas A en 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'"
   

   En este comando, se configura AppPass1! como la contraseña de la app de usuario.

3. Para verificar el estado de tu balanceador de cargas, ve a la página Balanceo de cargas en Cloud Console.

   ABRIR LA PÁGINA BALANCEO DE CARGAS

4. De la lista, selecciona el balanceador de cargas mqm-svc-a.

   

   Cuando el balanceador de cargas mqm-svc-a muestra que tiene un grupo de instancias en buen estado (como se ve en la captura de pantalla anterior), estás listo para ir al siguiente paso.

5. En Cloud Shell, inicia el administrador de colas B en 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. Inicia el administrador de colas B en 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'"
   

Cómo verificar el clúster

Antes de probar tu implementación, debes verificar que el administrador de colas A y el administrador de colas B se comuniquen correctamente.

1. En Cloud Shell, conéctate al contenedor de IBM MQ en mq-3:

   gcloud compute ssh mq-3 \
       --zone=us-central1-a \
       --command="sudo docker exec -it ibmmq-node /bin/bash" \
       -- -t
   

2. Comprueba el estado de los canales de comunicación del clúster:

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

   Si todo funciona correctamente, el resultado es el siguiente:

   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.
   

Cómo enviar mensajes al clúster

Ahora, debes probar el clúster mediante el envío de 2 mensajes a una cola llamada APP.QUEUE.1 con una aplicación de muestra proporcionada por IBM en la imagen de Docker.

Envía mensajes de prueba al administrador de colas B

1. En Cloud Shell, conéctate al contenedor de IBM MQ en mq-3:

   gcloud compute ssh mq-3 \
       --zone=us-central1-a \
       --command="sudo docker exec -it ibmmq-node /bin/bash" \
       -- -t
   

2. En el shell de la terminal, inicia la aplicación del remitente de mensajes que se conecta al administrador de colas B:

   MQSAMP_USER_ID=app /opt/mqm/samp/bin/amqsput APP.QUEUE.1 B
   

3. Cuando se te solicite, ingresa la contraseña de la app que creaste antes para realizar la autenticación (en este instructivo, es APPPass1!).

4. Cuando veas el mensaje que confirma que la cola de destino es APP.QUEUE.1, ingresa abcdef y envía un mensaje de prueba a la cola.

5. Ingresa 123456 para enviar otro mensaje de prueba.

6. Presiona Entrar para salir de la aplicación del remitente de mensajes.

   El resultado luce de la siguiente manera:

   Sample AMQSPUT0 start
   Enter password: *********
   target queue is APP.QUEUE.1
   abcdef
   123456
   
   Sample AMQSPUT0 end
   

7. Verifica que haya un mensaje en tránsito en el administrador de colas B:

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

   Hay un solo mensaje en tránsito porque el balanceo de cargas de IBM MQ dirigió el otro mensaje al administrador de colas A, como se describirá más adelante.

8. Cierra la conexión de SSH:

   exit
   

   Verás el siguiente resultado:

   CURDEPTH(1)                             IPPROCS(0)
   

   El administrador de colas B tiene un solo mensaje en tránsito, aunque en el paso anterior hayas enviado dos mensajes. Esto se debe a que IBM MQ balancea las cargas de los mensajes entre los administradores de colas; por eso, el segundo mensaje se envió al administrador de colas A.

Verifica los mensajes en tránsito en el administrador de colas A

1. En Cloud Shell, conéctate al contenedor de IBM MQ en mq-1:

   gcloud compute ssh mq-1 \
       --zone=us-central1-c \
       --command="sudo docker exec -it ibmmq-node /bin/bash" \
       -- -t
   

2. En la ventana de la terminal, verifica que haya un mensaje en tránsito en el administrador de colas A:

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

   Verás el siguiente resultado:

   CURDEPTH(1)                             IPPROCS(0)
   

Cómo probar la alta disponibilidad del administrador de colas

Ahora cierra la instancia mq-3 y verifica que mq-4 se convierta en la instancia principal para el administrador de colas B.

1. En Cloud Shell, detén la instancia mq-3:

   gcloud compute instances stop mq-3 \
       --zone=us-central1-a
   

2. Verifica que mq-4 se haya convertido en la instancia principal; para ello, comprueba que esté en buen estado desde la perspectiva del balanceador de cargas:

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

   Verás un resultado como el siguiente:

   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
   

Cómo trasladar a la producción

En este instructivo, se usó IBM MQ Advanced para desarrolladores. Antes de pasar a la producción, revisa otros conjuntos de atributos y licencias disponibles. También deberías revisar la documentación de IBM sobre cómo ejecutar IBM MQ en un contenedor antes de implementarlo en producción.

Limpieza

Una vez que hayas terminado el instructivo, puedes limpiar los recursos que creaste en Google Cloud para que no ocupen la cuota y no se te cobre en el futuro. En las siguientes secciones, se describe cómo borrar o desactivar estos recursos.

Borra el proyecto

Precaución: Borrar un proyecto tiene las consecuencias que se enumeran a continuación.
• Se borra todo en el proyecto. Si utilizaste un proyecto existente para este instructivo, cuando lo borres, también borrarás cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.
1. En Cloud Console, ve a la página Administrar recursos.

   Ir a la página Administrar recursos

2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

• Obtén más información sobre IBM MQ.
• Obtén información sobre las configuraciones de IBM MQ de alta disponibilidad.
• Obtén más información sobre los balanceadores de cargas internos.
• Obtén más información sobre GlusterFS.
• Prueba otras características de Google Cloud. Consulta nuestros instructivos.