Automating vRealize Suite Lifecycle Manager with Ansible – Part 1: Setup and Deploy vIDM and LCM

June 22, 2019July 16, 2019 Gavin Stephens 5 Comments

For many years I have been tasked with building vRealize Automation environments, and one of the biggest pain points, has been the deployment and preparation of the IaaS machines. This has usually required special preparation of a Windows template and a number of scripts to get everything configured, so that vRA plays nice. This is usually an error prone process, especially for the larger enterprise deployments. To tackle this problem, VMware released vRealize Suite Lifecycle Manager, which is on version 2.1, as of this writing.

I decided it was time to try this product and see if it lives up to the claims. I was also more interested in the API functionality, and as with all things automation, I typically turn to Ansible. I wasn’t too surprised to discover, that although the deployment is ‘automated’, depending on your interpretation, there is actually a number of manual steps that are still required. These include ensuring that the IaaS machines and database are already deployed and properly configured. The vRLCM Create Environment process also provides validation and pre-checks, along with scripts that can be used to prepare the machines.

With the preparation of these playbooks, I set out to automate the following:

Deployment of a single VMware vIDM appliance;
Deployment and initial configuration of a single vRealize Suite Lifecycle Manager appliance;
Deployment of vRealize Automation IaaS Servers (Windows VMs), in multiple deployment scenarios.
Creation of vRealize Automation environment through LCM.

This post will focus on deploying vRSLCM and vIDM with a follow-up post on the vRA deployments.

However, in my attempts to make this a set of one click processes, I wasn’t able to quite get that far (got pretty close). This was mainly due to some limitations with the vRSLCM API (can’t automate certificates, for example). I will discuss these limitations throughout this post, and if I find workarounds, then I’ll provide an update.

I should also point out that this is quite experimental and although I have done all that I can to make these workflows as idempotent as I can, unfortunately, with the limitations of the LCM API, this has proven to be quite difficult. These playbooks are best used as a one-time only deployment, at least for LCM itself.

Environment Preparation

In my environment I have a dedicated virtual machine that I develop and run my playbooks on (you may call this the Ansible control machine) running on CentOS 7.x.

Environment Overview

CentOS	CentOS 7.x
Ansible	2.8.1 (2.8 is a minimum requirement)
Python	3.6 (installed from EPEL Repository)

Prerequisites

The following pre-requisites are required:

DNS A/PTR records created for vRSLCM and vIDM appliances.

Prepare Environment

Ensure that the system is up-to-date by running:

sudo yum -y update

1	sudo yum -y update

Install yum-utils

sudo yum -y install yum-utils

1	sudo yum -y install yum-utils

Install Python 3

You will need to ensure that Python 3.6 is installed on your Ansible host. I am using the EPEL repository, but you may decided to use IUS or SCL to install these packages, so the package names may differ. Refer to the relevant documentation for installing Python 3 using these repositories, if required.

sudo yum -y install python36 python36-pip python36-devel

1	sudo yum -y install python36 python36-pip python36-devel

Install GIT

Git will be used to clone my Ansible vRSLCM playbooks repository.

sudo yum -y install git

1	sudo yum -y install git

Create Python Environment

It’s always the best approach to create a python virtual environment so that packages do not conflict with the base system. I have a directory in the root of my home dir called ‘python-env‘ where I maintain a number of different environments. Once you have a virtual environment set up, you just need to install the required packages from the ‘requirements.txt‘ file (provided later in the git repository).

You can follow these steps below to create a virtual environment:

mkdir ~/python-env
cd ~/python-dev
python3.6 -m venv ansible_vrlcm
source ansible_vrlcm/bin/activate

mkdir ~/python-env

cd ~/python-dev

python3.6 -m venv ansible_vrlcm

source ansible_vrlcm/bin/activate

You will notice that the shell will now display the virtual environment that you are using:

It’s also a good idea to ensure the latest version of pip and setuptools is installed.

pip install --upgrade pip setuptools

1	pip install --upgrade pip setuptools

IaC for vRealize: Deploying vRealize Build Tools To Allow Infrastructure As Code for vRA and vRO

June 12, 2019July 16, 2019 Gavin Stephens 12 Comments

As any vRealize Orchestrator developer will tell you, managing code outside of the appliance is difficult. I recently wrote a post about Using Visual Studio Code for your vRealize Orchestrator Development, where I highlighted some of the challenges with this. The issue is that we’re not given the freedom to use any IDE we want, easily run unit tests on our code or do continuous integration with tools like Jenkins.

I did mention that a couple of solutions were going to make their way, one of these was internal tooling that VMware’s CoE team currently uses for their vRO development (you can read the article here: https://blogs.vmware.com/management/2018/11/automating-at-scale-with-vro-and-vra.html). It wasn’t possible to get access to these tools without engaging with CoE and forking up a bit of cash.

That is until now, as VMware has released these tools as a new fling. The fling is currently in preview, but you can check it out here: https://labs.vmware.com/flings/vrealize-build-tools. I think this is quite an exciting time for VMware developers as these tools could finally change the way we develop and manage our code and integrate into the wider developer ecosystem.

This is my first blog on this topic but if I find these tools useful, then there will be plenty more to follow. Getting the environment set up to use these tools is not straight forward and has several dependencies. These include deploying supporting infrastructure such as JFrog Artifactory, preparing all the required artifacts that are sourced from the vRO server and getting the workstation set up to create and manage packages.

Deploy and Configure Platform

Before the developer can begin using the vRealize Build Tools, the supporting platform has to be deployed and configured. This consists of setting up an Artifactory server to store Maven artifacts and build dependencies and preparing the artifact repositories.

Deploy Artifactory Server (skip if you already have this deployed)

This section will detail how to set up the Artifactory server and required dependencies. Note that the details below only deploy a single Artifactory node with the database instance running on the same machine. It is recommended that for a production environment to ensure Artificatory is deployed with high availability and connects to external/dedicated database instances.

Install Java Development Kit (JDK)

JFrog Artifactory requires the Java JDK 8 and above to be installed and the JAVA_HOME variable configured. I am using the Open Source version of these tools. Install using the following command:

sudo yum install -y java-1.8.0-openjdk-devel

1	sudo yum install -y java-1.8.0-openjdk-devel

Add the following lines to ‘/etc/profile‘ to set the ‘JAVA_HOME‘ environment variable and add the Java bin directory to the path.

export JAVA_HOME=$(dirname $(dirname $(readlink $(readlink $(which javac)))))
export PATH=$PATH:$JAVA_HOME/bin

1 2	export JAVA_HOME=$(dirname $(dirname $(readlink $(readlink $(which javac))))) export PATH=$PATH:$JAVA_HOME/bin

Then source the file and check that the variables have been correctly configured:

source /etc/profile
env | grep JAVA_HOME
env | grep PATH

source /etc/profile

env | grep JAVA_HOME

env | grep PATH

vRealize Orchestrator: HTTP-REST Client

May 16, 2019May 16, 2019 Gavin Stephens Leave a comment

vRealize Orchestrator provides a nice way to manage and interact with web services. I have always liked that you can add HTTP-REST API endpoints, configured with basic authentication, which doesn’t require a token to be requested each time they are used. It’s also quite useful having visibility of these endpoints in the inventory, which makes them easy to discover.

It’s also possible to create operations on these endpoints (i.e. all the get/post operations), but I am not a big fan of using these. The problem, is that using them takes you that little bit further away from managing everything in code. They are also more difficult to port/migrate to other vRO instances, which is especially true if you have multiple environments for development, test, pre-prod, prod, etc. My much preferred method is to use Actions which perform these operations instead.

I have also seen many other developers use Actions for their HTTP-REST operations, which is good. The problem, however, is that I have seen these written in so many different ways. I decided that I needed to create a consistent experience when interacting with these web services and created the HTTP Rest Client. This client is a class with associated methods, that are used to make requests against a HTTP-REST web services.

You can download a package containing the HTTP-REST Client Action here.

HTTP REST Client

The client is an action that returns the HttpClient object. This object has a number of methods that can be used to execute requests against a web service. The following methods are supported:

GET, POST, PUT, DELETE and PATCH

The Action itself requires no inputs as these are provided when instantiating the object or supplied to the methods, when called.

Below is the code for the HttpClient class.

/**
 * Creates and returns an instance of the HttpClient object.
 * @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>
 * @version 1.0.0
 * @function httpClient
 * @returns {*} An instance of the HttpClient object.
 */

var logType = "Action";
var logName = "httpClient"; // This must be set to the name of the action
var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);
var log = new Logger(logType, logName);
var reqResponse = ""; //REST API request response

/**
 * Defines the HttpClient object.
 * @class
 * @param {REST:RESTHost} restHost - The HTTP REST host.
 * @param {string} [acceptType] - The encoding format to accept.
 * @returns {*} An instance of the HttpClient object.
 */

function HttpClient(restHost, acceptType) {
    this.restHost = restHost;

    if (acceptType) {
        this.acceptType = acceptType;
    } else {
        this.acceptType = "application/json";
    }

    /**
     * Defines the GET method.
     * @method
     * @param {string} restUri - The request uri.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this.get = function (restUri, expectedResponseCodes, headers) {
        reqResponse = this._executeRequest("GET", restUri, null, null,
                                           expectedResponseCodes, headers);

        return reqResponse;
    };

    /**
     * Defines the POST method.
     * @method
     * @param {string} restUri - The request uri.
     * @param {string} [content] - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this.post = function (restUri, content, contentType,
                          expectedResponseCodes, headers) {
        if (!content) {
            content = "{}";
        }
        reqResponse = this._executeRequest("POST", restUri, content,
                                           contentType, expectedResponseCodes,
                                           headers);

        return reqResponse;
    };

    /**
     * Defines the PUT method.
     * @method
     * @param {string} restUri - The request uri.
     * @param {string} content - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this.put = function (restUri, content, contentType,
                         expectedResponseCodes, headers) {
        reqResponse = this._executeRequest("PUT", restUri, content,
                                           contentType, expectedResponseCodes,
                                           headers);

        return reqResponse;
    };

    /**
     * Defines the DELETE method.
     * @method
     * @param {string} restUri - The request uri.
     * @param {string} content - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this.delete = function (restUri, content, contentType,
                            expectedResponseCodes, headers) {
        reqResponse = this._executeRequest("DELETE", restUri, content,
                                           contentType, expectedResponseCodes,
                                           headers);

        return reqResponse;
    };

    /**
     * Defines the PATCH method.
     * @method
     * @param {string} restUri - The request uri.
     * @param {string} content - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this.patch = function (restUri, content, contentType,
                           expectedResponseCodes, headers) {
        reqResponse = this._executeRequest("PATCH", restUri, content,
                                           contentType, expectedResponseCodes,
                                           headers);

        return reqResponse;
    };

    /**
     * A private method that executes the request.
     * @method
     * @private
     * @param {string} restMethod - The request method.
     * @param {string} restUri - The request uri.
     * @param {string} content - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {number[]} [expectedResponseCodes] - A list of expected response codes.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this._executeRequest = function (restMethod, restUri, content,
                                     contentType, expectedResponseCodes,
                                     headers) {
        var response;
        var maxAttempts = 5;
        var timeout = 10;
        var success = false;
        var statusCode;

        // Default to status code '200' if no expected codes have been defined.
        if (!expectedResponseCodes ||
            (Array.isArray(expectedResponseCodes) &&
            expectedResponseCodes.length < 1)) {
            expectedResponseCodes = [200];
        }
        this._createRequest(restMethod, restUri, content,
                            contentType, headers);

        log.debug("Executing request...");
        log.debug("URL: " + this.request.fullUrl);
        log.debug("Method: " + restMethod);

        for (var i = 0; i < maxAttempts; i++) {
            try {
                response = this.request.execute();
                success = true;
                break;
            } catch (e) {
                System.sleep(timeout * 1000);
                log.warn("Request failed: " + e + " retrying...");
                continue;
            }
        }

        if (!success) {
            log.error("Request failed after " + maxAttempts.toString +
                      " attempts. Aborting.");
        }

        statusCode = response.statusCode;
        if (expectedResponseCodes.indexOf(statusCode) > -1) {
            log.debug("Request executed successfully with status: " +
                      statusCode);
        } else {
            log.error("Request failed, incorrect response code received: '" +
                      statusCode + "' expected one of: '" +
                      expectedResponseCodes.join(",") +
                      "'\n" + response.contentAsString);
        }

        return response;
    };

    /**
     * A private method that creates the request.
     * @method
     * @private
     * @param {string} restMethod - The request method.
     * @param {string} restUri - The request uri.
     * @param {string} content - The request content.
     * @param {string} [contentType] - The encoding for content.
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     * @returns {*} The request response object.
     */

    this._createRequest = function (restMethod, restUri, content,
                                    contentType, headers) {
        var uri = encodeURI(restUri);

        log.debug("Creating REST request...");
        if (restMethod === "GET") {
            this.request = this.restHost.createRequest(restMethod, uri);
        } else {
            if (!content) {
                this.request = this.restHost.createRequest(restMethod, uri);
            } else {
                if (!contentType) {
                    contentType = this.acceptType;
                }
                this.request = this.restHost.createRequest(restMethod, uri, content);
                this.request.contentType = contentType;
            }
        }

        log.debug("Setting headers...");
        this._setHeaders(headers);
    };

    /**
     * A private method that sets the request headers.
     * @method
     * @private
     * @param {Properties} [headers] - A key/value set of headers to include in the request.
     */

    this._setHeaders = function (headers) {
        log.debug("Adding Header: Accept: " + this.acceptType);
        this.request.setHeader("Accept", this.acceptType);
        if (headers && (headers instanceof Properties)) {
            for (var headerKey in headers.keys) {
                var headerValue = headers.get(headerKey);
                // eslint-disable-next-line padding-line-between-statements
                log.debug("Adding Header: " + headerKey + ": " + headerValue);
                this.request.setHeader(headerKey, headerValue);
            }
        }
    };

}

return HttpClient;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

/**

* Creates and returns an instance of the HttpClient object.

* @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>

* @version 1.0.0

* @function httpClient

* @returns {*} An instance of the HttpClient object.

var logType = "Action";

var logName = "httpClient"; // This must be set to the name of the action

var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);

var log = new Logger(logType, logName);

var reqResponse = ""; //REST API request response

/**

* Defines the HttpClient object.

* @class

* @param {REST:RESTHost} restHost - The HTTP REST host.

* @param {string} [acceptType] - The encoding format to accept.

* @returns {*} An instance of the HttpClient object.

function HttpClient(restHost, acceptType) {

this.restHost = restHost;

if (acceptType) {

this.acceptType = acceptType;

} else {

this.acceptType = "application/json";

}

/**

* Defines the GET method.

* @method

* @param {string} restUri - The request uri.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this.get = function (restUri, expectedResponseCodes, headers) {

reqResponse = this._executeRequest("GET", restUri, null, null,

expectedResponseCodes, headers);

return reqResponse;

};

/**

* Defines the POST method.

* @method

* @param {string} restUri - The request uri.

* @param {string} [content] - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this.post = function (restUri, content, contentType,

expectedResponseCodes, headers) {

if (!content) {

content = "{}";

}

reqResponse = this._executeRequest("POST", restUri, content,

contentType, expectedResponseCodes,

headers);

return reqResponse;

};

/**

* Defines the PUT method.

* @method

* @param {string} restUri - The request uri.

* @param {string} content - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this.put = function (restUri, content, contentType,

expectedResponseCodes, headers) {

reqResponse = this._executeRequest("PUT", restUri, content,

contentType, expectedResponseCodes,

headers);

return reqResponse;

};

/**

* Defines the DELETE method.

* @method

* @param {string} restUri - The request uri.

* @param {string} content - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this.delete = function (restUri, content, contentType,

expectedResponseCodes, headers) {

reqResponse = this._executeRequest("DELETE", restUri, content,

contentType, expectedResponseCodes,

headers);

return reqResponse;

};

/**

* Defines the PATCH method.

* @method

* @param {string} restUri - The request uri.

* @param {string} content - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this.patch = function (restUri, content, contentType,

expectedResponseCodes, headers) {

reqResponse = this._executeRequest("PATCH", restUri, content,

contentType, expectedResponseCodes,

headers);

return reqResponse;

};

/**

* A private method that executes the request.

* @method

* @private

* @param {string} restMethod - The request method.

* @param {string} restUri - The request uri.

* @param {string} content - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {number[]} [expectedResponseCodes] - A list of expected response codes.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this._executeRequest = function (restMethod, restUri, content,

contentType, expectedResponseCodes,

headers) {

var response;

var maxAttempts = 5;

var timeout = 10;

var success = false;

var statusCode;

// Default to status code '200' if no expected codes have been defined.

if (!expectedResponseCodes ||

(Array.isArray(expectedResponseCodes) &&

expectedResponseCodes.length < 1)) {

expectedResponseCodes = [200];

}

this._createRequest(restMethod, restUri, content,

contentType, headers);

log.debug("Executing request...");

log.debug("URL: " + this.request.fullUrl);

log.debug("Method: " + restMethod);

for (var i = 0; i < maxAttempts; i++) {

try {

response = this.request.execute();

success = true;

break;

} catch (e) {

System.sleep(timeout * 1000);

log.warn("Request failed: " + e + " retrying...");

continue;

}

if (!success) {

log.error("Request failed after " + maxAttempts.toString +

" attempts. Aborting.");

}

statusCode = response.statusCode;

if (expectedResponseCodes.indexOf(statusCode) > -1) {

log.debug("Request executed successfully with status: " +

statusCode);

} else {

log.error("Request failed, incorrect response code received: '" +

statusCode + "' expected one of: '" +

expectedResponseCodes.join(",") +

"'\n" + response.contentAsString);

}

return response;

};

/**

* A private method that creates the request.

* @method

* @private

* @param {string} restMethod - The request method.

* @param {string} restUri - The request uri.

* @param {string} content - The request content.

* @param {string} [contentType] - The encoding for content.

* @param {Properties} [headers] - A key/value set of headers to include in the request.

* @returns {*} The request response object.

this._createRequest = function (restMethod, restUri, content,

contentType, headers) {

var uri = encodeURI(restUri);

log.debug("Creating REST request...");

if (restMethod === "GET") {

this.request = this.restHost.createRequest(restMethod, uri);

} else {

if (!content) {

this.request = this.restHost.createRequest(restMethod, uri);

} else {

if (!contentType) {

contentType = this.acceptType;

}

this.request = this.restHost.createRequest(restMethod, uri, content);

this.request.contentType = contentType;

}

log.debug("Setting headers...");

this._setHeaders(headers);

};

/**

* A private method that sets the request headers.

* @method

* @private

* @param {Properties} [headers] - A key/value set of headers to include in the request.

this._setHeaders = function (headers) {

log.debug("Adding Header: Accept: " + this.acceptType);

this.request.setHeader("Accept", this.acceptType);

if (headers && (headers instanceof Properties)) {

for (var headerKey in headers.keys) {

var headerValue = headers.get(headerKey);

// eslint-disable-next-line padding-line-between-statements

log.debug("Adding Header: " + headerKey + ": " + headerValue);

this.request.setHeader(headerKey, headerValue);

}

};

}

return HttpClient;

Using Visual Studio Code for your vRealize Orchestrator Development

May 10, 2019August 8, 2019 Gavin Stephens 8 Comments

Please note that this post was created before VMware released the vRealize Build Tools fling. I have a new series which covers using these tools and in effect, supersedes this post. Please check out my new series on IaC for vRealize: Deploying vRealize Build Tools To Allow Infrastructure As Code for vRA and vRO

When you are developing in a vRealize Orchestrator environment, one of the biggest frustrations is being limited to the vRO IDE. The vRO IDE is very simple, in that it does not provide any of the features that you would expect from an IDE, such as IntelliSense and quality of life extensions/addons, and only provides basic syntax checking.

There is no integration with source control management systems such as GIT (it has an internal system which isn’t great), moving code can be difficult and unit testing in the true sense of development, doesn’t exist. A connection to the vRO IDE uses a JAVA client and also requires a constant connection to the vRO server, so developing on the move or offline isn’t possible.

Anyone that has developed on this platform will have experienced the same issues and can only dream of the day when this is no longer the case.

You can use an IDE called Visual Studio Code, that can help make your development life easier. Admittedly, this alone doesn’t solve all of the discussed problems, but it does allow you to leverage the power of this IDE to assist in code development. There are still restrictions, such as lack of integration with vRO itself, which requires the code to be manually copied to the vRO server (yes, annoying). The good news, however, is that solutions are starting to become available to provide that integration. I am going to expand more on this at the end of this post.

If you haven’t heard of Visual Studio Code, it is a lightweight and features rich IDE created by Microsoft. The Visual Studio Code website describes it as:

Visual Studio Code combines the simplicity of a source code editor with powerful developer tooling, like IntelliSense code completion and debugging.

First and foremost, it is an editor that gets out of your way. The delightfully frictionless edit-build-debug cycle means less time fiddling with your environment, and more time executing on your ideas.

Visual Studio Code supports macOS, Linux, and Windows – so you can hit the ground running, no matter the platform.

I do almost all of my vRO development using Visual Studio Code, which gives me access to useful extensions and most importantly, keeps me in the mindset of how a developer should work.

In this post, I am going to cover how to set up a Visual Studio Code environment in Windows, install some useful extensions that I like to use and the installation of GIT and other required software components.

Setting Up Your Development Environment

The first thing that you will want to do, is download and install Visual Studio Code from here. When you launch this for the very first time, you’ll get an immediate good impression, from how quickly it loads and how lightweight it feels. The default dark theme is also quite nice.

vRA Developer: Part 8 – Working with vCAC Reservation Storage

May 9, 2019May 10, 2019 Gavin Stephens Leave a comment

In my previous post, I covered working with vcac reservations and provided examples of how you can retrieve property values and also linked entities, such as networks and virtual machines. In this post I am going to cover reserved storage. I planned to include this in the previous post, but the content was becoming too large, so I decided to split them.

The Actions provided here should be useful if you ever need to work with storage outside of vRA (for example, when adding or resizing a virtual hard disk directly in vCenter) and can be used to query reservation information first. This can prevent cases where storage can exceed that which is allocated/reserved for the tenant.

Here is how the reserved storage looks for the reservation that I will be working with:

All code that I have provided or talked about in this post can be downloaded as a vRO package for your consumption here.

I have also included a number of workflows in the package, which provide examples of these actions being used.

You can find these under ‘Simplygeek -> Library -> Common Workflows -> vRealize Automation -> Examples -> Reservations‘

Get Reserved Storage Information

The following sections provide vRO Actions that can be used to get information about storage that has been reserved in a reservation or get details of physical capacity.

Get Storage Reserved Capacity for a Reservation

The following action accepts a storage path and the reservation entity and will return the total amount of storage that has been reserved for the reservation.

/*global System vcacHost reservationEntity storagePath*/

/**
 * Gets the reserved storage capacity total for the storage path in the reservation.
 * @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>
 * @version 1.0.0
 * @function getReservedStorageCapacityTotalForReservation
 * @param {vCAC:VCACHOST} vcacHost - The vCAC Host.
 * @param {vCAC:Entity} reservationEntity - The vCAC reservation entity.
 * @param {string} storagePath - The storage path.
 * @returns {number} Returns the reserved storage capacity in GB.
 */

function checkParams(vcacHost, reservationEntity, storagePath) {
    var inputErrors = [];
    var errorMessage;

    if (!vcacHost || System.getObjectType(vcacHost) !== "vCAC:VCACHost") {
        inputErrors.push(" - vcacHost missing or not of type 'vCAC:VCACHost'");
    }
    if (!reservationEntity || System.getObjectType(reservationEntity) !== "vCAC:Entity") {
        inputErrors.push(" - reservationEntity missing or not of type 'vCAC:Entity'");
    }
    if (!storagePath || typeof storagePath !== "string") {
        inputErrors.push(" - storagePath missing or not of type 'string'");
    }
    if (inputErrors.length > 0) {
        errorMessage = "Mandatory parameters not satisfied:\n" + inputErrors.join("\n");
        log.error(errorMessage);
    }
}

var logType = "Action";
var logName = "getReservedStorageCapacityTotalForReservation"; // This must be set to the name of the action
var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);
var log = new Logger(logType, logName);
var reservedCapacityGB = 0;
var reservationName = "";
var hostReservationToStorages = [];
var resStoragePaths = [];
var query = "";
var entitySetName = "HostReservationToStorages";
var storageEntities = [];

try {
    checkParams(vcacHost, reservationEntity, storagePath);
    reservationName = reservationEntity.getProperty("HostReservationName");
    log.log("Getting reserved storage capacity total for '" + storagePath + "' in reservation '" + reservationName + "'");
    hostReservationToStorages = reservationEntity.getLink(vcacHost, "HostReservationToStorages");
    resStoragePaths = hostReservationToStorages.map(function(x){return x.getLink(vcacHost, "HostToStorage")[0].getProperty("StoragePath");});
    if (resStoragePaths.indexOf(storagePath) !== -1) {
        query = "HostToStorage/StoragePath eq '" + storagePath + "'";
        storageEntities = System.getModule("com.simplygeek.library.vcac.entities").getVcacEntitiesBySystemQuery(vcacHost,
                                                                                                                entitySetName,
                                                                                                                query);
        reservedCapacityGB = storageEntities[0].getProperty("MaxCapacity");
    } else {
        log.error("Storage path '" + storagePath + "' not found in reservation '" + reservationName + "'");
    }
    log.log("Reserved storage capacity total: " + reservedCapacityGB + " GB");
} catch (e) {
    log.error("Action failed to get reserved storage capacity total for vcac reservation.",e);
}

return reservedCapacityGB;

/*global System vcacHost reservationEntity storagePath*/

/**

* Gets the reserved storage capacity total for the storage path in the reservation.

* @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>

* @version 1.0.0

* @function getReservedStorageCapacityTotalForReservation

* @param {vCAC:VCACHOST} vcacHost - The vCAC Host.

* @param {vCAC:Entity} reservationEntity - The vCAC reservation entity.

* @param {string} storagePath - The storage path.

* @returns {number} Returns the reserved storage capacity in GB.

function checkParams(vcacHost, reservationEntity, storagePath) {

var inputErrors = [];

var errorMessage;

if (!vcacHost || System.getObjectType(vcacHost) !== "vCAC:VCACHost") {

inputErrors.push(" - vcacHost missing or not of type 'vCAC:VCACHost'");

}

if (!reservationEntity || System.getObjectType(reservationEntity) !== "vCAC:Entity") {

inputErrors.push(" - reservationEntity missing or not of type 'vCAC:Entity'");

}

if (!storagePath || typeof storagePath !== "string") {

inputErrors.push(" - storagePath missing or not of type 'string'");

}

if (inputErrors.length > 0) {

errorMessage = "Mandatory parameters not satisfied:\n" + inputErrors.join("\n");

log.error(errorMessage);

}

var logType = "Action";

var logName = "getReservedStorageCapacityTotalForReservation"; // This must be set to the name of the action

var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);

var log = new Logger(logType, logName);

var reservedCapacityGB = 0;

var reservationName = "";

var hostReservationToStorages = [];

var resStoragePaths = [];

var query = "";

var entitySetName = "HostReservationToStorages";

var storageEntities = [];

try {

checkParams(vcacHost, reservationEntity, storagePath);

reservationName = reservationEntity.getProperty("HostReservationName");

log.log("Getting reserved storage capacity total for '" + storagePath + "' in reservation '" + reservationName + "'");

hostReservationToStorages = reservationEntity.getLink(vcacHost, "HostReservationToStorages");

resStoragePaths = hostReservationToStorages.map(function(x){return x.getLink(vcacHost, "HostToStorage")[0].getProperty("StoragePath");});

if (resStoragePaths.indexOf(storagePath) !== -1) {

query = "HostToStorage/StoragePath eq '" + storagePath + "'";

storageEntities = System.getModule("com.simplygeek.library.vcac.entities").getVcacEntitiesBySystemQuery(vcacHost,

entitySetName,

query);

reservedCapacityGB = storageEntities[0].getProperty("MaxCapacity");

} else {

log.error("Storage path '" + storagePath + "' not found in reservation '" + reservationName + "'");

}

log.log("Reserved storage capacity total: " + reservedCapacityGB + " GB");

} catch (e) {

log.error("Action failed to get reserved storage capacity total for vcac reservation.",e);

}

return reservedCapacityGB;

vRA Developer: Part 7 – Working with vCAC Reservation Entities

May 3, 2019May 9, 2019 Gavin Stephens Leave a comment

Reservations are created in vRA to allocate memory, storage and network resources to a business group. Business groups can consume these resources by provisioning virtual machines.

In this post I am going to cover the vCAC Reservation Entities and provide some workflows and actions that can be used to get information about reservations programmatically. This can be useful to gather information about the reservations if you are using custom XaaS processes that would not trigger the standard built-in reservation checks.

All code that I have provided or talked about in this post can be downloaded as a vRO package for your consumption here.

I have also included a number of workflows in the package, which provide examples of these actions being used.

You can find these under ‘Simplygeek -> Library -> Common Workflows -> vRealize Automation -> Examples -> Reservations‘

Get a List of Available Reservations or Get a Specific Reservation

The following code can be used to get a list of all reservations that are available for the specified tenant or retrieve a specific reservation based on its name or unique id.

This is specifically the reservation that I will be working with and will appear in the log outputs.

Get List of Available Reservations For a Tenant

The following code will accept a tenant Id and a toggle for retrieving only enabled reservations. A list of reservation string names will be returned. This isn’t as straight forward as you would hope (at least from an entities point of view), because there is no property for the tenant id on the reservation. Instead, I had to inspect the business group that the reservation is assigned to, which does have a tenant id property (it’s quite possible this is how the gui does it too).

/*global vcacHost tenantId enabledOnly*/

/**
 * Gets a list of reservations that have been created for the
 * specified tenant id.
 * @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>
 * @version 1.0.0
 * @function getListOfReservationNamesForTenant
 * @param {vCAC:VCACHOST} vcacHost - The vCAC Host.
 * @param {string} tenantId - The tenant id.
 * @param {boolean} [enabledOnly] - Show only Enabled reservations?
 * @returns {string[]} return a list of reservations for the tenant.
 */

function checkParams(vcacHost, tenantId) {
    var inputErrors = [];
    var errorMessage;

    if (!vcacHost || System.getObjectType(vcacHost) !== "vCAC:VCACHost") {
        inputErrors.push(" - vcacHost missing or not of type 'vCAC:VCACHost'");
    }
    if (!tenantId || typeof tenantId !== "string") {
        inputErrors.push(" - tenantId missing or not of type 'string'");
    }
    if (inputErrors.length > 0) {
        errorMessage = "Mandatory parameters not satisfied:\n" + inputErrors.join("\n");
        log.error(errorMessage);
    }
}

var logType = "Action";
var logName = "getListOfReservationNamesForTenant"; // This must be set to the name of the action
var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);
var log = new Logger(logType, logName);
var entitySetName = "HostReservations";
var reservationNames = [];
var numReservations = 0;
var query = "";
var reservationEntities = [];
var enabledReservations = true;

try {
    checkParams(vcacHost, tenantId);
    log.log("Getting a list of reservations for tenant: " + tenantId);
    if (!enabledOnly) {
        enabledReservations = false;
    }
    query = "ProvisioningGroup/TenantID eq '" + tenantId.toLowerCase() + "'";
    if (enabledReservations) {
        query += " and Enabled eq " + enabledReservations;
    }
    reservationEntities = System.getModule("com.simplygeek.library.vcac.entities").getVcacEntitiesBySystemQuery(vcacHost,
                                                                                                                entitySetName,
                                                                                                                query);
    numReservations = reservationEntities.length;
    reservationNames = reservationEntities.map(function(x){return x.getProperty("HostReservationName");});
    for (var i = 0; i < numReservations; i++) {
        var reservationName = reservationEntities[i].getProperty("HostReservationName");
        var reservationId = reservationEntities[i].getProperty("HostReservationID");

        log.log("Found reservation '" + reservationName + "' with id '" + reservationId + "'");
    }
    log.log("Found a total of " + numReservations + " reservation(s).");
} catch (e) {
    log.error("Failed to get a list of reservations for tenant.",e);
}

return reservationNames;

/*global vcacHost tenantId enabledOnly*/

/**

* Gets a list of reservations that have been created for the

* specified tenant id.

* @author Gavin Stephens <gavin.stephens@simplygeek.co.uk>

* @version 1.0.0

* @function getListOfReservationNamesForTenant

* @param {vCAC:VCACHOST} vcacHost - The vCAC Host.

* @param {string} tenantId - The tenant id.

* @param {boolean} [enabledOnly] - Show only Enabled reservations?

* @returns {string[]} return a list of reservations for the tenant.

function checkParams(vcacHost, tenantId) {

var inputErrors = [];

var errorMessage;

if (!vcacHost || System.getObjectType(vcacHost) !== "vCAC:VCACHost") {

inputErrors.push(" - vcacHost missing or not of type 'vCAC:VCACHost'");

}

if (!tenantId || typeof tenantId !== "string") {

inputErrors.push(" - tenantId missing or not of type 'string'");

}

if (inputErrors.length > 0) {

errorMessage = "Mandatory parameters not satisfied:\n" + inputErrors.join("\n");

log.error(errorMessage);

}

var logType = "Action";

var logName = "getListOfReservationNamesForTenant"; // This must be set to the name of the action

var Logger = System.getModule("com.simplygeek.library.util").logger(logType, logName);

var log = new Logger(logType, logName);

var entitySetName = "HostReservations";

var reservationNames = [];

var numReservations = 0;

var query = "";

var reservationEntities = [];

var enabledReservations = true;

try {

checkParams(vcacHost, tenantId);

log.log("Getting a list of reservations for tenant: " + tenantId);

if (!enabledOnly) {

enabledReservations = false;

}

query = "ProvisioningGroup/TenantID eq '" + tenantId.toLowerCase() + "'";

if (enabledReservations) {

query += " and Enabled eq " + enabledReservations;

}

reservationEntities = System.getModule("com.simplygeek.library.vcac.entities").getVcacEntitiesBySystemQuery(vcacHost,

entitySetName,

query);

numReservations = reservationEntities.length;

reservationNames = reservationEntities.map(function(x){return x.getProperty("HostReservationName");});

for (var i = 0; i < numReservations; i++) {

var reservationName = reservationEntities[i].getProperty("HostReservationName");

var reservationId = reservationEntities[i].getProperty("HostReservationID");

log.log("Found reservation '" + reservationName + "' with id '" + reservationId + "'");

}

log.log("Found a total of " + numReservations + " reservation(s).");

} catch (e) {

log.error("Failed to get a list of reservations for tenant.",e);

}

return reservationNames;

Log output:

[] [I] [Action: getListOfReservationNamesForTenant] Getting a list of reservations for tenant: sg
[] [I] [Action: getListOfReservationNamesForTenant] Found reservation 'RES-SITEA-vSphere-Resource-01' with id '8e1534f6-c65c-412b-af8b-b4ad8ee3c6cb'
[] [I] [Action: getListOfReservationNamesForTenant] Found a total of 1 reservation(s).

[] [I] [Action: getListOfReservationNamesForTenant] Getting a list of reservations for tenant: sg

[] [I] [Action: getListOfReservationNamesForTenant] Found reservation 'RES-SITEA-vSphere-Resource-01' with id '8e1534f6-c65c-412b-af8b-b4ad8ee3c6cb'

[] [I] [Action: getListOfReservationNamesForTenant] Found a total of 1 reservation(s).

Deploying NSX-T Using Ansible – Part 3: Running The Playbook

April 10, 2019April 10, 2019 Gavin Stephens Leave a comment

In this post I am going to cover the running of the Ansible NSX-T playbook, so that you can get NSX-T deployed in your environment(s). In case you missed them, in my previous posts, I detailed how to set up your Ansible environment and configure the playbook in preparation for deploying NSX-T.

If you arrived here and want to figure it out for yourself, you can download my playbooks here: https://github.com/nmshadey/Ansible-NSXT

Playbook Overview

The main playbook that you will need to run is called ‘nsxt_create_environment.yml‘, which is located in the root of the Ansible-NSXT folder.

---
## Deploys an NSX-T environment
- hosts: nsxt_managers_controllers
  connection: local
  become: yes
  gather_facts: False
  vars:
    nsxt_deployment_vcenter: "{{ mgmt_vcenter_server }}"
    nsxt_deployment_vcenter_username: "{{ mgmt_vcenter_admin_username }}"
    nsxt_deployment_vcenter_password: "{{ mgmt_vcenter_admin_password }}"
    nsxt_deployment_datacenter: "{{ mgmt_vcenter_datacenter }}"
    nsxt_deployment_cluster: "{{ mgmt_vcenter_cluster }}"
    nsxt_deployment_datastore: "{{ nsxt_datastore }}"
    nsxt_deployment_portgroup: "{{ nsxt_portgroup }}"
    nsxt_deployment_size: "{{ nsxt_default_deployment_size }}"
    nsxt_role: "{{ nsxt_default_role }}"

    compute_managers:
    - name: "{{ nsxt_compute_manager_name }}"
      host: "{{ nsxt_compute_manager_host }}"
      transport_clusters: "{{ nsxt_transport_clusters }}"

    ip_pools:
    - display_name: "{{ nsxt_transport_switch_ip_pool_name }}"
      subnets:
      - allocation_ranges:
        - start: "{{ nsxt_transport_switch_ip_pool_start }}"
          end: "{{ nsxt_transport_switch_ip_pool_end }}"
        cidr: "{{ nsxt_transport_switch_ip_pool_cidr }}"

    transport_zones:
    - display_name: "{{ nsxt_transport_zone_name }}"
      description: "{{ nsxt_transport_zone_desc }}"
      transport_type: "OVERLAY"
      transport_switch_name: "{{ nsxt_transport_switch_name }}"

    uplink_profiles:
    - display_name: "{{ nsxt_transport_switch_uplink_profile_name }}"
      teaming:
        active_list:
        - uplink_name: "{{ nsxt_transport_switch_uplink_1 }}"
          uplink_type: PNIC
        - uplink_name: "{{ nsxt_transport_switch_uplink_2 }}"
          uplink_type: PNIC
        policy: "{{ nsxt_transport_switch_uplink_profile_policy }}"
      transport_vlan: "{{ nsxt_transport_switch_uplink_profile_vlan }}"

    transport_node_profiles:
    - display_name: "{{ nsxt_transport_node_profile_name }}"
      description: "{{ nsxt_transport_switch_profile_desc }}"
      host_switches:
      - host_switch_profiles:
        - name: "{{ nsxt_transport_switch_uplink_profile_name }}"
          type: UplinkHostSwitchProfile
        host_switch_name: "{{ nsxt_transport_switch_name }}"
        pnics:
        - device_name: "{{ nsxt_transport_switch_pnic_1 }}"
          uplink_name: "{{ nsxt_transport_switch_uplink_1 }}"
        - device_name: "{{ nsxt_transport_switch_pnic_2 }}"
          uplink_name: "{{ nsxt_transport_switch_uplink_2 }}"
        ip_assignment_spec:
          resource_type: StaticIpPoolSpec
          ip_pool_name: "{{ nsxt_transport_switch_ip_pool_name }}"
      transport_zone_endpoints:
      - transport_zone_name: "{{ nsxt_transport_zone_name }}"
    
  roles:
    - nsxt_deploy_ova
    - nsxt_apply_license
    - nsxt_add_compute_managers
    - nsxt_create_ip_pools
    - nsxt_create_transport_zones
    - nsxt_create_uplink_profiles
    - nsxt_create_transport_profiles
    - nsxt_configure_transport_clusters

---

## Deploys an NSX-T environment

- hosts: nsxt_managers_controllers

connection: local

become: yes

gather_facts: False

vars:

nsxt_deployment_vcenter: "{{ mgmt_vcenter_server }}"

nsxt_deployment_vcenter_username: "{{ mgmt_vcenter_admin_username }}"

nsxt_deployment_vcenter_password: "{{ mgmt_vcenter_admin_password }}"

nsxt_deployment_datacenter: "{{ mgmt_vcenter_datacenter }}"

nsxt_deployment_cluster: "{{ mgmt_vcenter_cluster }}"

nsxt_deployment_datastore: "{{ nsxt_datastore }}"

nsxt_deployment_portgroup: "{{ nsxt_portgroup }}"

nsxt_deployment_size: "{{ nsxt_default_deployment_size }}"

nsxt_role: "{{ nsxt_default_role }}"

compute_managers:

- name: "{{ nsxt_compute_manager_name }}"

host: "{{ nsxt_compute_manager_host }}"

transport_clusters: "{{ nsxt_transport_clusters }}"

ip_pools:

- display_name: "{{ nsxt_transport_switch_ip_pool_name }}"

subnets:

- allocation_ranges:

- start: "{{ nsxt_transport_switch_ip_pool_start }}"

end: "{{ nsxt_transport_switch_ip_pool_end }}"

cidr: "{{ nsxt_transport_switch_ip_pool_cidr }}"

transport_zones:

- display_name: "{{ nsxt_transport_zone_name }}"

description: "{{ nsxt_transport_zone_desc }}"

transport_type: "OVERLAY"

transport_switch_name: "{{ nsxt_transport_switch_name }}"

uplink_profiles:

- display_name: "{{ nsxt_transport_switch_uplink_profile_name }}"

teaming:

active_list:

- uplink_name: "{{ nsxt_transport_switch_uplink_1 }}"

uplink_type: PNIC

- uplink_name: "{{ nsxt_transport_switch_uplink_2 }}"

uplink_type: PNIC

policy: "{{ nsxt_transport_switch_uplink_profile_policy }}"

transport_vlan: "{{ nsxt_transport_switch_uplink_profile_vlan }}"

transport_node_profiles:

- display_name: "{{ nsxt_transport_node_profile_name }}"

description: "{{ nsxt_transport_switch_profile_desc }}"

host_switches:

- host_switch_profiles:

- name: "{{ nsxt_transport_switch_uplink_profile_name }}"

type: UplinkHostSwitchProfile

host_switch_name: "{{ nsxt_transport_switch_name }}"

pnics:

- device_name: "{{ nsxt_transport_switch_pnic_1 }}"

uplink_name: "{{ nsxt_transport_switch_uplink_1 }}"

- device_name: "{{ nsxt_transport_switch_pnic_2 }}"

uplink_name: "{{ nsxt_transport_switch_uplink_2 }}"

ip_assignment_spec:

resource_type: StaticIpPoolSpec

ip_pool_name: "{{ nsxt_transport_switch_ip_pool_name }}"

transport_zone_endpoints:

- transport_zone_name: "{{ nsxt_transport_zone_name }}"

roles:

- nsxt_deploy_ova

- nsxt_apply_license

- nsxt_add_compute_managers

- nsxt_create_ip_pools

- nsxt_create_transport_zones

- nsxt_create_uplink_profiles

- nsxt_create_transport_profiles

- nsxt_configure_transport_clusters

Deploying NSX-T Using Ansible – Part 2: Setting Up The Playbook

April 10, 2019April 11, 2019 Gavin Stephens Leave a comment

In my previous post I covered how to prepare your Ansible environment and install the VMware NSX-T modules. I also provided the details on how to install my Ansible playbooks for deploying NSX-T in your environments.

In this post I am going to detail how to configure these playbooks to meet your environment/requirements. I have chosen to break out my variables into multiple files. This gives me the flexibility to assign values specific to a group of hosts, inherit values from a parent group and to store usernames, passwords and license information more securely, in their own Ansible Vault encrypted file.

The deployment examples that I will demonstrate include 2 sites, that each include the following:

A management environment at each site. This includes a vCenter Server instance with a single management cluster.
A compute resource (CMP) environment at each site. This includes a vCenter Server instance with a single resource cluster.

I will deploy an NSX-T instance at each management cluster. These NSX-T instances will be used to provide SDN capabilities to the compute resource clusters (when I get time I’ll create a diagram!).

An overview of the playbook tree:

├── ansible.cfg
├── nsxt_create_environment.yml
├── nsxt_example_add_compute_manager.yml
├── nsxt_example_apply_license.yml
├── nsxt_example_create_ip_pools.yml
├── nsxt_example_create_transport_profiles.yml
├── nsxt_example_create_transport_zones.yml
├── nsxt_example_create_uplink_profiles.yml
├── nsxt_example_deploy_ova.yml
├── group_vars
│   ├── all
│   ├── nsxt_managers_controllers
│   ├── site_a
│   ├── site_a_cmp_nsxt
│   ├── site_b
│   └── site_b_cmp_nsxt
├── inventory
│   └── hosts
├── roles
│   ├── nsxt_add_compute_managers
│   ├── nsxt_apply_license
│   ├── nsxt_check_manager_status
│   ├── nsxt_configure_transport_clusters
│   ├── nsxt_create_ip_pools
│   ├── nsxt_create_transport_profiles
│   ├── nsxt_create_transport_zones
│   ├── nsxt_create_uplink_profiles
│   └── nsxt_deploy_ova
├── ssh_config

├── ansible.cfg

├── nsxt_create_environment.yml

├── nsxt_example_add_compute_manager.yml

├── nsxt_example_apply_license.yml

├── nsxt_example_create_ip_pools.yml

├── nsxt_example_create_transport_profiles.yml

├── nsxt_example_create_transport_zones.yml

├── nsxt_example_create_uplink_profiles.yml

├── nsxt_example_deploy_ova.yml

├── group_vars

│ ├── all

│ ├── nsxt_managers_controllers

│ ├── site_a

│ ├── site_a_cmp_nsxt

│ ├── site_b

│ └── site_b_cmp_nsxt

├── inventory

│ └── hosts

├── roles

│ ├── nsxt_add_compute_managers

│ ├── nsxt_apply_license

│ ├── nsxt_check_manager_status

│ ├── nsxt_configure_transport_clusters

│ ├── nsxt_create_ip_pools

│ ├── nsxt_create_transport_profiles

│ ├── nsxt_create_transport_zones

│ ├── nsxt_create_uplink_profiles

│ └── nsxt_deploy_ova

├── ssh_config