Tutoriel - équilibrage de charge des messages syslog à l’aide d’extensions de protocole

Le protocole Syslog disponible sur l’appliance Citrix ADC fonctionne uniquement pour les messages générés sur l’appliance Citrix ADC. Il n’équilibre pas la charge des messages provenant de nœuds externes. Pour équilibrer la charge de ces messages, vous devez utiliser la fonction d’extensions de protocole et écrire la logique d’analyse des messages syslog en utilisant le langage de programmation Lua 5.2.

Code pour l’analyse du message syslog

Le code a uniquement la fonction de rappel des données du client TCP définie - client.on_data(). Pour les données du serveur, il n’ajoute pas de fonction de rappel et le serveur au client prend le chemin natif rapide. Le code identifie la limite du message en fonction du caractère de fin. Si le paquet TCP contient plus d’un message syslog, nous divisons le paquet en fonction du caractère de fin et de l’équilibre de charge de chaque message.

--[[

  Syslog event handler for TCP client data

    ctxt - TCP client side App processing context.

    data - TCP Data stream received.

--]]

function client.on_data(ctxt, payload)

                  local message = nil

                  local data_len

                  local data = payload.data

                  local trailing_character = "\n"

                  ::split_message::

                                    -- Get the offset of trailing character

                                    local new_line_character_offset = data:find(trailing_character)

                                    -- If trailing character is not found, then wait for more data.

                                    if (not new_line_character_offset) then

                                                      goto need_more_data

                                    end

                                    -- Get the length of the current message

                                    data_len = data:len()

                                    -- Check whether we have more than one message

                                    -- by comparing trailing character offset and

                                    -- current data length

                                    if (data_len > new_line_character_offset) then

                                                      -- If we have more than one message, then split

                                                      -- the data into two parts such that first part

                                                      -- will contain message upto trailing character

                                                      -- offset and second part will contain

                                                      -- remaining message.

                                                      message, data = data:split(new_line_character_offset)

                                    else

                                                      message = data

                                                      data = nil

                                    end

-- Send the data to the backend server.

                                    ns.send(ctxt.output, "EOM", {data = message})

                                    goto done

                                    ::need_more_data::

                                                      -- Wait for more data

                                                      ctxt:hold(data)

                                                      data = nil

                                                      goto done

                                    ::done::

                                                      -- If we have more data to parse,

                                                      -- then do parsing again.

                                                      if (data) then

                                                                        goto split_message

                                                      end

end

Tutoriel - équilibrage de charge des messages syslog à l’aide d’extensions de protocole