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.

    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.

Arquitectura del sistema MQ 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.

    Página de Console para balanceadores de cargas, en la que se muestran mq-group1 y mq-group2

    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

  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?