Home

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

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

name (Required, Default: none, name of the pool)
nodes (Optional, Default: none, comma separated list of nodes and their ports. E.g. node01.example.com:80,node02.example.com:80....)
priority (Optional, Default: 10, priority assigned to all nodes)
state (Optional, Default: active, whether a node is active in the pool or not. Applies to all nodes in the pool)
weight (Optional, Default: 1, weighting assigned to a node in the pool. Applies equally to all nodes)

Create a pool

$ ./go-brocade-vtm-cli pool-create -name example-pool -nodes node01.example.com:80,node02.example.com:80

Show pools

Show a list of pools and their associated HRef

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

Show the attributes for a pool

$ ./go-brocade-vtm-cli pool-show -name example-pool

Update pool

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 pool-update -name example-pool -nodes node01.example.com:80,node02.example.com:80,node03.example.com:80 -state draining

Delete pool

$ ./go-brocade-vtm-cli pool-delete -name example-pool

Working with rules

Before creating a rule a Brocade vTM Traffic Script needs to be created in a file on the local machine.

Example Traffic Script

if( http.responseHeaderExists( "Keep-Alive" ) == 0) {
  http.removeResponseHeader( "Keep-Alive" ); 
}

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 example-rule -script /path/to/traffic_script

Showing rules

To list all rules and their associated HRef.

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

To show a rule called 'example-rule'.

$ ./go-brocade-vtm-cli rule-show -name example-rule

Updating a rule

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

$ ./go-brocade-vtm-cli rule-update -name example-rule -script /path/to/updated_traffic_script

Deleting a rule

To delete a rule

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

Working with SSL Server Keys

Before adding a SSL Server Key to the Brocade vTM create the private key (RSA), certificate and CSR. The following assumes an appropriate OpenSSL configuration exists. The values given are just for example and not recommendations.

Create CSR and private key

$ openssl req -new -newkey rsa:4096 -nodes -keyout example.com.key -out example.com.csr -subj "/CN=example.com" -config open_ssl.cnf

Generate certificate

$ openssl req -x509 -sha256 -days 365 -key example.com.key -in example.com.csr -out example.com.crt

The following attributes are implemented for SSL Server Keys:

name (Required, Default: none, the name of the SSL Server Key)
note (Optional, Default: none, a note assigned to the SSL Server Key)
certificate-file (Optional, Default: none, the path to a valid certificate file)
csr-file (Optional, Default: none, the path to a valid CSR file)
private-key-file (Optional, Default: none, the path to a valid private key file)

Create a SSL Server Key

$ ./go-brocade-vtm-cli ssl-server-key-create -name example-ssl-key -note example.com -certificate-file /path/to/example.com.crt -csr-file /path/to/example.com.csr -private-key-file /path/to/example.com.key

Show SSL Server Keys

Show a list of SSL Server Keys and their associated HRef

$ ./go-brocade-vtm-cli ssl-server-key-show-all

Show a SSL Server Key (doesn't include the private key)

$ ./go-brocade-vtm-cli ssh-server-key-show -name example-ssl-key

Update SSL Server Key

$ ./go-brocade-vtm-cli ssl-server-key-update -name example-ssl-key -note another-example.com -certificate-file /path/to/another-example.com.crt -csr-file /path/to/another-example.com.csr -private-key-file /path/to/another-example.com.key

Delete SSL Server Key

$ ./go-brocade-vtm-cli ssl-server-key-delete -name example-ssl-key

Working with Traffic IP Groups

Create a Traffic IP Group

Show Traffic IP Groups

Update a Traffic IP Group

Delete a Traffic IP Group

*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.