WebSphere Message Broker, Versión 8.0.0.5 Sistemas operativos: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Consulte la información sobre la última versión del producto en IBM Integration Bus, Versión 9.0

Utilización de un intermediario con un gestor de alta disponibilidad existente

Puede utilizar WebSphere Message Broker Versión 8.0 con un gestor de alta disponibilidad existente, por ejemplo HACMP, HA/XD, VCS o HP-UX Serviceguard.

Con la introducción de los intermediarios de mensajes multiinstancia en WebSphere Message Broker Versión 7.0, la configuración de WebSphere Message Broker Versión 8.0 con un gestor de alta disponibilidad (HA) es mucho más fácil. Anteriormente, se proporcionaba el paquete de soporte IC91 para ayudarle a configurar este requisito.

Se proporcionan diversos scripts, pero la mayoría de ellos ya no son necesarios porque WebSphere Message Broker Versión 8.0 tiene incorporadas muchas de las funciones como resultado del trabajo multiinstancia.

En este tema se presenta de forma resumida cómo llevar a cabo las siguientes tareas:
  1. Crear un intermediario.
  2. Añadir una instancia de intermediario.
  3. Iniciar un intermediario.
  4. Detener un intermediario.
  5. Supervisar un intermediario.
  6. Suprimir un intermediario.
  1. Para crear un intermediario, monte el recurso compartido en su nodo primario y utilice el siguiente mandato mqsicreatebroker con el parámetro -e para especificar la ubicación de recursos compartidos.
     mqsicreatebroker MyBroker -q MQ1 -e /MQHA/MyBroker/
    donde:
    • MyBroker es el nombre del intermediario.
    • MQ1 es el nombre del gestor de colas.
    • /MQHA/MyBroker/ es el directorio de su recurso compartido.
  2. Para añadir otra instancia de intermediario, monte el recurso compartido en los nodos secundarios y utilice el siguiente mandato mqsiaddbrokerinstance.
     mqsiaddbrokerinstance MyBroker –e /MQHA/MyBroker/
    donde:
    • MyBroker es el nombre del intermediario.
    • /MQHA/MyBroker/ es el directorio de su recurso compartido.
  3. Para iniciar un intermediario, puede utilizar uno de los archivos script siguientes:
    hamqsi_start_broker
    #!/bin/ksh
    # Module:
    #   hamqsi_start_broker
    #
    # Args:
    #   BROKER = name of broker to start
    #
    # Description:
    #   This script attempts to start the MQSI Broker
    #
    #   Runs as the userid which runs broker, and must have 
    #   the user's environment (i.e. invoke from "su - $MQUSER ..")
    #
    
    BROKER=$1
    
    if [ -z "$BROKER" ]
    then
      echo "hamqsi_start_broker: ERROR! No Broker name supplied"
      echo "   Usage: hamqsi_start_broker <BROKER>" 
      exit 1
    fi
    
    # Ensure that the broker is not already running. In this test
    # we look for any broker-related processes, which might have
    # been left around after a previous failure. Any that remain
    # must now be terminated. This is a brutal means of mopping 
    # up broker processes.
    # We stop the processes in the following order:
    #   bipservice       - first so it cannot issue restarts
    #   bipbroker        - next for same reason
    #   biphttplistener
    #   startDataFlowEngine
    #   DataFlowEngine  - last
    #
    echo "hamqsi_start_broker: Ensure $BROKER not already running"
    for process in bipservice bipbroker biphttplistener startDataFlowEngine
    DataFlowEngine
    do
      # Output of kill redirected to /dev/null in case no processes
      ps -ef | grep "$process $BROKER" | grep -v grep | \
         awk '{print $2}'| xargs kill -9 > /dev/null 2>&1
    done
    
    
    # Start the Broker 
    echo "hamqsi_start_broker: Start Broker " $BROKER
    mqsistart $BROKER > /dev/null 2>&1
    if [ $? -ne "0" ]
    then 
      echo "hamqsi_start_broker: Bad result from mqsistart for $BROKER"
      exit 1
    fi
    
    # Check to see if the broker service has started. This loop 
    # uses a fixed online timeout of approx. 10 seconds.
    TIMED_OUT=yes
    i=0
    while [ $i -lt 10 ]
    do
      # Check for Broker start. We look for bipservice and 
      # bipbroker to be running; there might be no message flows
      # deployed.
      # Look to see whether bipservice is running
      cnt=`ps -ef | grep "bipservice $BROKER" | grep -v grep | wc -l`
      if [ $cnt -gt 0 ]
      then
        # Look to see whether bipbroker is running
        cnt=`ps -ef | grep "bipbroker $BROKER" | grep -v grep | wc -l`
        if [ $cnt -gt 0 ]
        then
          # Broker is online
          echo "hamqsi_start_broker: ${BROKER} is running"
          TIMED_OUT=no
          break  # out of timing loop
        fi
      fi
      # Manage the loop counter
      i=`expr $i + 1`
      sleep 1
    done
    
    # Report error if broker failed to start in time
    if [ ${TIMED_OUT} = "yes" ]
    then 
      echo "hamqsi_start_broker: Broker service failed to start: " $BROKER
      exit 1
    fi
    
    exit 0
    hamqsi_start_broker_as
    #
    #!/bin/ksh
    # Module:
    #   hamqsi_start_broker_as
    #
    # Args:
    #   broker = broker name
    #   qm     = name of broker queue manager
    #   mquser = user account under which QM and Broker are run
    #
    # Description:
    #   Starting an MQSI Broker requires the following services:
    #   (1) The MQSeries Queue Manager which supports the Broker  
    #   (2) The MQSI Broker service 
    #   This script provides a single source to initiate the required 
    #   services in sequence. 
    #  
    #   Queue Manager:
    #   This script uses the strmqm script supplied by MQSeries V7
    #  
    #   Broker:
    #   This script then invokes the hamqsi_start_broker script which 
    #   checks that the broker is fully stopped and then starts it.
    #
    #   The hamqsi_start_broker_as script should be run as root.
    
    
    
    # Check running as root
    if [ `id -u`  -ne 0 ]
    then
      echo "Must be running as root"
      exit 1
    fi
    
     
    BROKER=$1
    QM=$2
    MQUSER=$3
    
    # Check all parameters exist
    
    if [ -z "$BROKER" ]
    then
      echo "hamqsi_start_broker_as: ERROR! No Broker name supplied"
      echo "  Usage: hamqsi_start_broker_as <BROKER> <QM> <MQUSER>"
      exit 1
    fi
    
    if [ -z "$QM" ]
    then
      echo "hamqsi_start_broker_as: ERROR! No queue manager name supplied"
      echo "  Usage: hamqsi_start_broker_as <BROKER> <QM> <MQUSER>"
      exit 1
    fi
    
    if [ -z "$MQUSER" ]
    then
      echo "hamqsi_start_broker_as: ERROR! No Userid supplied"
      echo "  Usage: hamqsi_start_broker_as <BROKER> <QM> <MQUSER>"
      exit 1
    fi
    
    # ------------------------------------------------------------------- 
    # Start the Queue Manager 
    #
    echo "hamqsi_start_broker_as: Start Queue manager " $QM 
    su $MQUSER -c "/opt/mqm/bin/strmqm $QM"
    rc=$?
    if [ $rc -ne 0 ]
    then
      echo "hamqsi_start_broker_as: Could not start the queue manager"
      exit $rc
    fi
    
    # ------------------------------------------------------------------- 
    # Start the Broker
    #
    # Ensure that the Broker is not already running and start the Broker 
    su - $MQUSER -c "/MQHA/bin/hamqsi_start_broker $BROKER"
    rc=$?
    if [ $rc -ne 0 ]
    then
      echo "hamqsi_start_broker_as: Could not start the broker"
      exit $rc
    fi
    
    exit $rc
  4. Para detener un intermediario, puede utilizar uno de los archivos de script siguientes:
    hamqsi_stop_broker
    #!/bin/ksh
    # Module:
    #   hamqsi_stop_broker
    #
    # Args:
    #   broker = name of broker
    #   timeout = max time to allow for each phase of termination
    #
    # Description:
    #   This script stops the broker, forcibly if necessary.
    #   The script should be run by the user account under which 
    #   the broker is run, including environment. 
    
    BROKER=$1
    TIMEOUT=$2
    
    if [ -z "$BROKER" ]
    then
      echo "hamqsi_stop_broker: ERROR! No broker name supplied"
      echo "   Usage: hamqsi_stop_broker <BROKER> <TIMEOUT>"
      exit 1
    fi
    
    if [ -z "$TIMEOUT" ]
    then
      echo "hamqsi_stop_broker: ERROR! No timeout supplied"
      echo "   Usage: hamqsi_stop_broker <BROKER> <TIMEOUT>"
      exit 1
    fi
    
    for severity in normal immediate terminate
    do
      # Issue the stop method in the background - we don't
      # want to risk having it hang us up, indefinitely. We
      # want to be able to concurrently run a TIMEOUT timer
      # to give up on the attempt, and try a more forceful 
      # stop. If the kill version fails then there is nothing 
      # more we can do here anyway.
      
      echo "hamqsi_stop_broker: Attempting ${severity} stop of ${BROKER}"
      case $severity in
    
      normal)
        # Minimum severity of stop is to issue mqsistop
        mqsistop $BROKER > /dev/null 2>&1 &
        ;;
    
      immediate)
        # This is an immediate stop.
        mqsistop $BROKER -i > /dev/null 2>&1 &
        ;;
    
      terminate)
        # This is a brutal means of mopping up Broker processes.
        # We stop the processes in the following order:
        #   bipservice       - first so it cannot issue restarts
        #   bipbroker        - next for same reason
        #   biphttplistener
        #   startDataFlowEngine
        #   DataFlowEngine  - last
        for process in bipservice bipbroker biphttplistener startDataFlowEngine
        DataFlowEngine 
            do
          # Output of kill redirected to /dev/null in case no processes
          ps -ef | grep "$process $BROKER" | grep -v grep | \
            awk '{print $2}'| xargs kill -9 > /dev/null 2>&1
        done
        ;;
    
      esac
    
      echo "hamqsi_stop_broker: Waiting for ${severity} stop of ${BROKER} to complete"
      TIMED_OUT=yes
      SECONDS=0
      while (( $SECONDS < ${TIMEOUT} ))
      do
        # See whether there are any broker processes still running 
        cnt=`ps -ef | \
          grep -E "bipservice $BROKER|bipbroker $BROKER|startDataFlowEngine 
          $BROKER|DataFlowEngine $BROKER|biphttplistener $BROKER" | \
          grep -v grep | wc -l`
        if [ $cnt -gt 0 ]
        then
          # It's still running...wait for timeout
          sleep 1 # loop granularity
        else
          # It's stopped, as desired
          echo "${BROKER} has stopped"
          TIMED_OUT=no
          break # out of while ..offline timeout loop
        fi
      done # timeout loop
    
      if [ ${TIMED_OUT} = "yes" ]
      then
        continue        # to next level of urgency
      else
        break           # instance is stopped, job is done
      fi
    
    done # next level of urgency
    
    if [ ${TIMED_OUT} = "no" ]
    then
      echo "hamqsi_stop_broker: Completed"
      exit 0
    else
      echo "hamqsi_stop_broker: Completed with errors"
      exit 1
    fi 
    hamqsi_stop_broker_as
    #!/bin/ksh
    # Module:
    #   hamqsi_stop_broker_as
    #
    # Arguments are:
    #   broker = name of broker 
    #   qm     = name of broker queue manager
    #   mquser = user account under which QM and broker run
    #   timeout = max time to allow each phase of stop processing
    #
    # Description:
    #   This script stops the Broker, Queue Manager in that sequence.
    #  
    #   Broker:
    #   The script invokes the hamqsi_stop_broker script to stop the 
    #   broker, which checks that the broker is fully stopped.
    #  
    #   Queue Manager:
    #   This script uses the strmqm script supplied by MQSeries V7 
    #  
    #   The hamqsi_stop_broker_as script should be run as root. 
    
    
    # Check running as root
    if [ `id -u`  -ne 0 ]
    then
      echo "Must be running as root"
      exit 1
    fi
    
     
    BROKER=$1
    QM=$2
    MQUSER=$3
    TIMEOUT=$4
    
    # Check all parameters
    
    if [ -z "$BROKER" ]
    then
      echo "hamqsi_stop_broker_as: ERROR! No Broker name supplied"
      echo "   Usage: hamqsi_stop_broker_as <BROKER> <QM> <MQUSER> <TIMEOUT>"
      exit 1
    fi
    
    if [ -z "$QM" ]
    then
      echo "hamqsi_stop_broker_as: ERROR! No queue manager name supplied"
      echo "   Usage: hamqsi_stop_broker_as <BROKER> <QM> <MQUSER> <TIMEOUT>"
      exit 1
    fi
    
    if [ -z "$MQUSER" ]
    then
      echo "hamqsi_stop_broker_as: ERROR! No userid supplied"
      echo "   Usage: hamqsi_stop_broker_as <BROKER> <QM> <MQUSER> <TIMEOUT>"
      exit 1
    fi
    
    if [ -z "$TIMEOUT" ]
    then
      echo "hamsi_stop_broker_as: ERROR! No Timeout value supplied"
      echo "   Usage: hamqsi_stop_broker_as <BROKER> <QM> <MQUSER> <TIMEOUT>"
     exit 1
    fi
    
    
    METHOD_STATUS="OK"
    
    # ------------------------------------------------------------------- 
    # Stop the BROKER
    #
    echo "hamqsi_stop_broker_as: Stop Broker " $BROKER
    su - $MQUSER -c "/MQHA/bin/hamqsi_stop_broker $BROKER $TIMEOUT"
    if [ $? -ne "0" ]
    then
      # Even if the above operation failed, just report and then continue by 
      # stopping other components
      echo "hamqsi_stop_broker_as: Attempt to stop broker $BROKER failed"
      METHOD_STATUS="Error"
    fi
    
    # ------------------------------------------------------------------- 
    # Stop the Queue Manager, using script from MQ V7
    #
    echo "hamqsi_stop_broker_as: Stop Queue Manager $QM"
    su $MQUSER -c "/opt/mqm/bin/endmqm -i $QM"
    if [ $? -ne "0" ]
    then
      # Even if the above operation failed, just report and then continue by 
      # stopping other components
      echo "hamqsi_stop_broker_as: Attempt to stop queue manager $QM failed"
      METHOD_STATUS="Error"
    fi
    
    if [ ${METHOD_STATUS} = "OK" ]
    then
      exit 0
    else
      echo "hamqsi_stop_broker_as: Completed with errors"
      exit 1
    fi
  5. Para supervisar un intermediario, puede utilizar el archivo de script siguiente que comprueba solamente la existencia de los procesos del intermediario principal y proporciona un código de retorno satisfactorio si los encuentra:
    hamqsi_monitor_broker_as
    #!/bin/ksh
    # Module:
    #   hamqsi_monitor_broker_as
    #
    # Args:
    #   BROKER = name of broker in AppServer
    #   QM     = name of queue manager in AppServer
    #   MQUSER = userid under which queue manager and broker run
    # 
    # Description:
    #   This is the application monitor script used with HACMP/ES. It 
    #   needs to be invoked by a parameter-less wrapper script because
    #   HACMP does not allow parameters to be passed to application
    #   monitor scripts.
    #  
    #   This hamqsi_monitor_broker_as script is run as root, and uses 
    #   su as needed to monitor the 3 components of the application server.
    #  
    #   This script is tolerant of a queue manager that is still in
    #   startup. If the queue manager is still starting this application 
    #   monitor script will exit with 0 - which indicates
    #   to HACMP that there's nothing wrong. This is to allow for
    #   startup time for the queue manager which might exceed the 
    #   Stabilisation Interval set for the Application Monitor in HACMP/ES.
    #    
    #  
    # Exit codes:
    #   0  => Broker & QM are all running OK or starting
    #   >0 => One or more components are not responding.
    #
    
    # Check running as root
    if [ `id -u`  -ne 0 ]
    then
      echo "Must be running as root"
      exit 1
    fi
    
    BROKER=$1
    QM=$2
    MQUSER=$3
    
    # Check the parameters
    
    if [ -z "$BROKER" ]
    then
      echo "hamqsi_monitor_broker_as: ERROR! No broker name supplied"
      exit 1
    fi
    
    if [ -z "$QM" ]
    then
      echo "hamqsi_monitor_broker_as: ERROR! No queue manager name supplied"
      exit 1
    fi
    
    if [ -z "$MQUSER" ]
    then
      echo "hamqsi_monitor_broker_as: ERROR! No mquser supplied"
      exit 1
    fi
    
    # Use a state variable to reflect the state of components as they
    # are tested. Valid values are "stopped", "starting" and "started"
    # Initialise it to "stopped" for safety. 
    STATE="stopped"
    
    # ------------------------------------------------------------------
    # Check that the queue manager is running or starting.
    #
    su - $MQUSER -c "echo 'ping qmgr' | runmqsc ${QM}" > /dev/null 2>&1
    pingresult=$?
    # pingresult will be 0 on success; non-zero on error (man runmqsc)
    if [ $pingresult -eq 0 ]
    then 
      # ping succeeded
      echo "hamqsi_monitor_broker_as: Queue Manager ${QM} is responsive"
      STATE="started"
    else 
      # ping failed
      # Don't condemn the QM immediately, it might be in startup.
      # The following regexp includes a space and a tab, so use tab-friendly
      # editors.
      srchstr=" $QM[  ]*$"
      cnt=`ps -ef | grep strmqm | grep "$srchstr" | grep -v grep \
                    | awk '{print $2}' | wc -l`
      if [ $cnt -gt 0 ]
      then
        # It appears that QM is still starting up, tolerate
        echo "hamqsi_monitor_broker_as: Queue Manager ${QM} is starting"
        STATE="starting"
      else
        # There is no sign of QM start process
        echo "hamqsi_monitor_broker_as: Queue Manager ${QM} is not responsive"
        STATE="stopped"
      fi
    fi
    
    
    # Decide whether to continue or to exit
    case $STATE in
      stopped)
        echo "hamqsi_monitor_broker_as: Queue manager ($QM) is not running correctly"
        exit 1  
        ;;
      starting)
        echo "hamqsi_monitor_broker_as: Queue manager ($QM) is starting"
        echo "hamqsi_monitor_broker_as: WARNING - Stabilisation Interval might be too short"
        echo "hamqsi_monitor_broker_as: WARNING - No test of broker $BROKER will be conducted"
        exit 0  
        ;;
      started)
        echo "hamqsi_monitor_broker_as: Queue manager ($QM) is running"
        continue 
        ;;
    esac
    
    # ------------------------------------------------------------------
    # Check the MQSI Broker is running 
    # 
    # Re-initialise STATE for safety
    STATE="stopped"
    #
    # The broker runs as a process called bipservice which is responsible
    # for starting and re-starting the admin agent process (bipbroker). 
    # The bipbroker is responsible for starting any DataFlowEngines. The 
    # bipbroker starts the DataFlowEngines using the wrapper script 
    # startDataFlowEngine. If no execution groups have been assigned to 
    # the broker there will be no DataFlowEngine processes. There should 
    # always be a bipservice and bipbroker process pair. This monitor 
    # script only tests for bipservice, because bipservice should restart 
    # bipbroker if necessary - the monitor script should not attempt to 
    # restart bipbroker and it might be premature to report an absence 
    # of a bipbroker as a failure.
    #
    cnt=`ps -ef | grep "bipservice $BROKER" | grep -v grep | wc -l`
    if [ $cnt -eq 0 ]
    then 
      echo "hamqsi_monitor_broker_as: MQSI Broker $BROKER is not running"
      STATE="stopped"
    else
      echo "hamqsi_monitor_broker_as: MQSI Broker $BROKER is running" 
      STATE="started"
    fi
    
    # Decide how to exit
    case $STATE in
      stopped)
        echo "hamqsi_monitor_broker_as: Broker ($BROKER) is not running correctly"
        exit 1  
        ;;
      started)
        echo "hamqsi_monitor_broker_as: Broker ($BROKER) is running"
        exit 0 
       ;;
    esac 
    Si necesita más información que la que se suministra en el ejemplo anterior, puede codificar el supervisor para que lleve a cabo las siguientes acciones:
    • Suscríbase a datos de contabilidad y estadísticos de WebSphere Message Broker y analice los resultados.
    • Coloque un mensaje ficticio en el intermediario y analice los resultados.
  6. Antes de suprimir el intermediario del nodo principal, debe suprimir los intermediarios en los nodos de espera. Para suprimir un intermediario, utilice el mandato mqsiremovebrokerinstance de los nodos secundarios y el mandato mqsideletebroker en el nodo primario.

Para obtener más información acerca de la configuración de WebSphere MQ con un gestor de disponibilidad, consulte Centro de información en línea de WebSphere MQ Versión 7.

Consulte el:
  • Mandato addmqinf
  • Mandato dspmqinf
  • Mandato rmvmqinf
y la opción -md en el mandato crtmqm.
Avisos | Marcas registradas | Descargas | Biblioteca | Soporte | Comentarios

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Última actualización:
        
        Última actualización: 2015-02-28 17:01:13


Tema de tareaTema de tarea | Versión 8.0.0.5 | be13730_