Skip to content

Home

Jump to bottom
ppwarwick edited this page Jul 26, 2017 · 28 revisions

go-brocadev-tm - Go Bindings for the Brocade Virtual Traffic Manager (vTM)

Overview

This is the GoLang API wrapper for Brocade Virtual Traffic Manager (vTM). This wrapper uses the REST API interface provided by the vTM, currently version 3.8. There is also command line interface which can be built by running make in the root of this repo.

Handled Resources

Resource Create Read Update Delete
Monitor [1] Y Y Y Y
Pool Y Y Y Y
SSL Server Key Y Y Y Y
Traffic IP Group Y Y Y Y
Virtual Server Y Y Y Y
Rule Y Y Y Y

Notes

[1] : Currently only HTTP monitoring is supported

Usage

Import library

import(
    "github.com/sky-uk/go-brocade-vtm"
)

Get a client object

In order to get a client object authentication credentials needs to be provided. The REST API transport protocol is by default HTTPS and hence SSL encryption is used by default. Certificate handling behaviour can be controlled via the ignoreSSL flag. More information about the client and the Base API may be found here https://github.com/sky-uk/go-rest-api.

Working with Monitors

Required Import

In order to work with monitors, import the monitor package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/monitor"
)

Getting the list of active monitors

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monitors := api.ResponseObject().(*monitor.MonitorsList)

Retrieving a single monitor

    api := monitor.NewGet( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monitor := api.ResponseObject().(*monitor.Monitor)

Creating a monitor

    newMonitor := monitor.Monitor{
        ...
    }

    api := monitor.NewCreate( name, newMonitor )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monCreated := api.ResponseObject().(*monitor.Monitor)

Updating a monitor

    updateMonitor := monitor.Monitor{
        ...
    }

    api := monitor.NewUpdate( name, updateMonitor )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monUpdated := api.ResponseObject().(*monitor.Monitor)

Deleting a monitor

    api := monitor.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Monitor %s deleted", name)
    }

Working with Pools

Required Import

In order to work with pools, import the pool package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/pool"
)

Getting the list of pools

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    pools := api.ResponseObject().(*pool.LBPoolList)

Retrieving a single pool

    api := monitor.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    pool := api.ResponseObject().(*pool.Pool)

Creating a pool

    newPool := pool.Pool{
        ...
    }

    api := pool.NewCreate( name, newPool )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    poolCreated := api..ResponseObject().(*pool.Pool)

Updating a pool

    updatePool := pool.Pool{
        ...
    }

    api := pool.NewUpdate( name, updatePool )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    poolUpdated := api.ResponseObject().(*pool.Pool)

Deleting a pool

    api := pool.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Pool %s deleted", name)
    }

Working with Server keys

Required Import

In order to work with server keys, import the pool package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/sslServerKey"
)

Getting the list of server keys

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keys := api.ResponseObject().(*sslServerKey.SSLServerKeysList)

Retrieving a single server key

    api := sslServerKey.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    key := api.ResponseObject().(*sslServerKey.SSLServerKey)

Creating a server key

    newKey := sslServerKey.SSLServerKey{
        ...
    }

    api := sslServerKey.NewCreate( name, newKey )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keyCreated := api.ResponseObject().(*sslServerKey.SSLServerKey)

Updating a server key

    updateKey := sslServerKey.SSLServerKey{
        ...
    }

    api := sslServerKey.NewUpdate( name, updateKey )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keyUpdated := api.ResponseObject().(*sslServerKey.SSLServerKey)

Deleting a server key

    api := sslServerKey.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Server key %s deleted", name)
    }

Working with traffic IP groups

Required Import

In order to work with traffic IP groups, import the traffic IP package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/trafficIpGroups"
)

Getting the list of traffic IP groups

    // to get the list of all traffic managers
    api := trafficIpGroups.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroups := api.ResponseObject().(*trafficIpGroups.TrafficIPGroupList)

Retrieving a single traffic IP group

    api := trafficIpGroups.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroup := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Creating a traffic IP group

    newTipg := trafficIpGroups.TrafficIPGroup{
        ...
    }

    api := trafficIpGroups.NewCreate( name, newTipg )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    tipgCreated := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Updating a traffic IP group

    updateTipg := trafficIpGroups.TrafficIPGroup{
        ...
    }

    api := trafficIpGroups.NewUpdate( name, updateTipg )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    tipgUpdated := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Deleting a traffic IP group

    api := trafficIpGroups.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Traffic IP group %s deleted", name)
    }

Working with Traffic IP Group Managers

Traffic IP Group Managers are only used by Traffic IP Group to retrieve a list of Traffic Mangers when creating a Traffic IP Group.

Required Import

In order to work with Traffic IP Group Managers, import the Traffic IP Group package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/traffic_ip_group_managers"
)

Getting the list of Traffic IP Group Managers

    api := trafficIpGroupManager.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroupManagers := api.ResponseObject().(*trafficIpGroupManager.TrafficManagerChildren)

Working with virtual servers

Required Import

In order to work with virtual servers, import the virtual server package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/virtualserver"
)

Getting the list of virtual servers

    api := virtualserver.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    virtualServer := api.ResponseObject().(*virtualserver.VirtualServersList)

Retrieving a single virtual server

    api := virtualserver.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    virtualServer := api.ResponseObject().(*virtualserver.VirtualServer)

Creating a virtual server

    newVS := virtualserver.VirtualServer{
        ...
    }

    api := virtualserver.NewCreate( name, newVS )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    vsCreated := api.ResponseObject().(*virtualserver.VirtualServer)

Updating a virtual server

    updateVS := virtualserver.VirtualServer{
        ...
    }

    api := virtualserver.NewUpdate( name, updateVS )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    vsUpdated := api.ResponseObject().(*virtualserver.VirtualServer)

Deleting a virtual server

    api := virtualserver.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Virtual server %s deleted", name)
    }

Working with rules

Required Import

 In order to work with rules, import the rule package section:
 
 ```
 import (
     "github.com/sky-uk/go-brocade-vtm/api/rule"
 )
 ```

Getting the list of rules

    api := rule.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    rules := api.ResponseObject().(*rule.Rules)

Retrieving a single rule

    api := rule.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    // Returns the traffic script as a string
    trafficScript := api.ResponseObject().(*[]byte)

Creating a rule

    ruleName := "my-rule"
    trafficScript := []byte(`
            if( string.ipmaskmatch( request.getremoteip(), "192.168.123.10" ) ){
                    connection.discard();
            }`)
    
    api := rule.NewCreate( ruleName, trafficScript )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

Updating a rule

    ruleName := "my-rule"
    updatedTrafficScript := []byte(`
                                     if( string.ipmaskmatch( request.getremoteip(), "192.168.123.10" ) ){
                                             connection.discard();
                                     }`)
                                     
    api := rule.NewUpdate( ruleName, updatedTrafficScript )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

Deleting a rule

    nameRuleToDelete := "my-rule"

    api := rule.NewDelete( nameRuleToDelete )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Rule %s deleted", nameRuleToDelete)
    }

Using the CLI

Run make in the root of the repository to build the go-brocade-vtm-cli binary. Once built the binary may be found in the root of the repository.

Authentication

Set the following shell environment variables to allow the cli to make changes to a Brocade vTM. Note that the cli automatically prefixes the value of BROCADEVTM_SERVER with https://.

$ export BROCADEVTM_USERNAME=admin
$ export BROCADEVTM_PASSWORD=myPassword
$ export BROCADEVTM_SERVER=my-brocade-vtm.example.com:9070

Getting help

$ ./go-brocade-vtm-cli -h

Working with monitors

Monitor is partially implemented. The following attributes may be specified when creating or updating a monitor:

  • authentication (Optional, Default: none, basic-auth string used to authenticate when testing a service)
  • delay (Optional, Default: 3, minimum seconds between calls to an endpoint)
  • failures (Optional, Default: 3, number of consecutive failed calls to an endpoint)
  • http-body-regex (Optional, Default: none, regular expression patter to match in the response body)
  • http-host-header (Optional, Default: none, host header sent in test request)
  • http-path (Optional, Default: '/', the endpoint to call)
  • name (Required, Default: none, name of the monitor)
  • timeout (Optional, Default: 3, maximum runtime of a call to an endpoint)
  • type (Optional, Default: http, type of monitor to use when calling an endpoint)
  • use-ssl (Optional, Default: false, whether the monitor should use SSL when calling the endpoint)
  • verbose (Optional, Default: false, whether the monitor should emit verbose logging)
Create a monitor
$ ./go-brocade-vtm-cli monitor-create -name example-monitor -delay 10 -failures 2 -http-path /health-check -timeout 2 -verbose -type http
Show monitors

Show all monitors and their associated endpoint

$ ./go-brocade-vtm-cli monitor-show-all

Show a monitor and it's attributes

$ ./go-brocade-vtm-cli monitor-show -name example-monitor
Update monitor

Note: if an attribute isn't specified on the command line it will revert to it's default. See above for defaults.

$ ./go-brocade-vtm-cli monitor-update -name example-monitor -delay 10 -failures 2 -http-path /my-app/health-check -timeout 2 -verbose -type http
Delete monitor
$ ./go-brocade-vtm-cli monitor-delete -name example-monitor

Working with pools

Create a pool
Show pools
Update pool
Delete pool

Working with rules

Create a rule

To create a rule ensure the traffic script is in the file /path/to/traffic_script.

$ ./go-brocade-vtm-cli rule-create -name my-rule -script /path/to/traffic_script
Showing rules

To list all rules.

$ ./go-brocade-vtm-cli rule-show-all

To show a rule called 'my-rule'.

$ ./go-brocade-vtm-cli rule-show -name my-rule
Updating a rule

To update a rule called 'my-rule' with the traffic script (file) /path/to/updated_traffic_script.

$ ./go-brocade-vtm-cli rule-update -name my-rule -script /path/to/updated_traffic_script
Deleting a rule

To delete a rule

$ ./go-brocade-vtm-cli rule-delete -name my-rule

Working with SSL Server Keys

Create a SSL Server Key
Show SSL Server Keys
Update SSL Server Key
Delete SSL Server Key

Working with Traffic IP Groups

*Note: Traffic IP Groups uses Traffic IP Group Managers to obtain a list of Traffic Managers. Traffic IP Group Managers isn't for direct use.

Working with Virtual Servers

Create a Virtual Server
Show Virtual Servers
Update Virtual Server
Delete Virtual Server
Clone this wiki locally