cloudlab 1.2.2__py3-none-any.whl

cloudlab/__init__.py

@@ -0,0 +1 @@
+# this file is intentionally empty

cloudlab/commandline.py

@@ -0,0 +1,294 @@
+import argparse
+import importlib.resources
+import json
+import logging
+import os
+import os.path
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import time
+
+import jinja2
+import yaml
+
+CLOUDFORMATION_TEMPLATE_NAME = 'cf.yaml'
+CONFIG_FILE_NAME = 'cloudlab_config.yaml'
+config = None  # config is global
+
+
+def print_sample():
+    sample = importlib.resources.files('cloudlab').joinpath('resources/cloudlab_config.yaml').read_text()
+    print(sample)
+
+
+def run():
+    global config
+
+    parser = argparse.ArgumentParser(prog='cloudlab', description='Declarative lab environment builder for AWS')
+    parser.add_argument("command", choices=['mkenv', 'rmenv', 'update', 'sample'])
+    parser.add_argument("environment", nargs="?", default="cloudlab", help='A unique name for the environment')
+    parser.add_argument("--plan", default='aws_with_subnets', help='The name of the template to use when creating this environment')
+    parser.add_argument("--no-provision", dest='provision', action='store_false', help='Generate the CloudFormation template but do not provision the environment')
+
+    args = parser.parse_args()
+
+    if args.command == 'sample':
+        print_sample()
+        sys.exit(0)
+
+    if not os.path.isfile(CONFIG_FILE_NAME):
+        sys.exit(f'Exiting because the configuration file is not present. For a starter configuration file, run  "cloudlab sample > {CONFIG_FILE_NAME}"')
+
+    with open(CONFIG_FILE_NAME, 'r') as config_file:
+        config = yaml.safe_load(config_file)
+
+    envdir = args.environment
+    command = args.command
+    template = f'{args.plan}.yaml.j2'
+    provision = args.provision
+
+    logging.basicConfig(format='%(asctime)s:%(message)s', level=logging.DEBUG)
+
+    # validate that the environment directory, which is also used as an AWS CloudFormation stack name, is valid
+    valid_stack_name_re = r"[a-zA-Z][-a-zA-Z0-9]*"
+    if re.fullmatch(valid_stack_name_re, envdir) is None:
+        sys.exit(f'"{envdir}" is not a valid environment name.  Because it used as an AWS CloudFormation stack name, '
+                 f'it must match the following regular expression: "{valid_stack_name_re}"')
+
+    if command == 'mkenv':
+        mkenv(envdir, False, template, provision)
+    elif command == 'rmenv':
+        rmenv(envdir)
+    elif command == 'update':
+        mkenv(envdir, True, template, provision)
+
+
+def rmenv(envdir):
+    if envdir.endswith('/'):
+        envdir = envdir[0:-1]
+
+    envname = os.path.basename(envdir)
+
+    runaws('aws cloudformation delete-stack --stack-name={}'.format(envname))
+    logging.info("Deleted cloud formation stack: %s", envname)
+
+    runaws('aws ec2 delete-key-pair --key-name={}'.format(envname))
+    logging.info('Deleted the AWS key pair named %s.', envname + '.pem')
+
+    shutil.rmtree(envdir, ignore_errors=True)
+    logging.info('Removed cloudlab environment: %s.', envdir)
+
+
+def mkenv(envdir, update, template, provision):
+    global config
+
+    # retrieve the template file
+    j2loader = jinja2.PackageLoader('cloudlab', 'plans')
+    j2env = jinja2.Environment(loader=j2loader, lstrip_blocks=True, trim_blocks=True)
+    try:
+        j2_template = j2env.get_template(template)
+    except jinja2.exceptions.TemplateNotFound:
+        sys.exit(f'cloudlab template not found: {template}')
+
+    # convert private_ip_suffixes to private_ip_addresses for each server
+    for subnet in config['subnets']:
+        for group in subnet['servers']:
+            private_ip_addresses = []
+            for suffix in group['private_ip_suffixes']:
+                private_ip_addresses.append( make_ip(subnet['cidr'], suffix))
+
+            group['private_ip_addresses'] = private_ip_addresses
+
+    # create the directory
+    if envdir.endswith('/'):
+        envdir = envdir[0:-1]
+
+    envname = os.path.basename(envdir)
+
+    if update:
+        if not os.path.exists(envdir):
+            sys.exit('Environment directory does not exist. Exiting.')
+        # else:
+        #     shutil.rmtree(envdir, ignore_errors=True)
+        #     logging.info('Removed cloudlab environment directory: %s.', envdir)
+
+    else:
+        if os.path.exists(envdir):
+            sys.exit('Environment directory already exists. Exiting.')
+
+        os.makedirs(envdir)
+        logging.info('Created directory %s', envdir)
+
+    # generate the yaml file and save it to the target environment
+    config['key_pair_name'] = envname
+
+    # render the template
+    cf_template_file = os.path.join(envdir, CLOUDFORMATION_TEMPLATE_NAME)
+    with open(cf_template_file, 'w') as f:
+        j2_template.stream(config=config).dump(f)
+
+    logging.info(f'Generated Cloud Formation Template: {cf_template_file}')
+    if not provision:
+        return
+
+    # create the key pair
+    keyfile_name = os.path.join(envdir, envname + '.pem')
+    if not update:
+        result = runaws('aws ec2 create-key-pair --key-name={}'.format(envname))
+
+        with open(keyfile_name, 'w') as f:
+            f.write(result['KeyMaterial'])
+
+        os.chmod(keyfile_name, stat.S_IRUSR | stat.S_IWUSR)
+
+        logging.info('Created a new key pair and saved the private key to {}.'.format(keyfile_name))
+
+    # deploy to AWS using Cloud Formation
+    nowait = False
+    if update:
+        # first we need to figure out the latest event related to this stack so we can start watching events after that
+        result = runaws(f'aws cloudformation describe-stack-events --stack-name={envname}')
+        last_event_timestamp = result['StackEvents'][0]['Timestamp']
+
+        result = runaws_result('aws cloudformation update-stack '
+                               f'--stack-name={envname} '
+                               f'--template-body=file://{cf_template_file}')
+
+        if result.returncode != 0:
+            if 'No updates are to be performed'  in str(result.stdout):
+                nowait = True
+                logging.info("The Cloudformation stack is already up to date")
+            else:
+                sys.exit(f'An error occurred while updating the Cloudformation stack: {result.stdout}')
+
+        else:
+            logging.info('Waiting for stack update to complete.')
+    else:
+        runaws('aws cloudformation create-stack '
+               f'--stack-name={envname} '
+               f'--template-body=file://{cf_template_file}')
+
+        logging.info('Cloud Formation stack created.  Waiting for provisioning to complete.')
+
+    # use aws cloudformation describe-stack-events to follow the progress
+    done = nowait
+    previously_seen = dict()
+    while not done:
+        time.sleep(5.0)
+        result = runaws(f'aws cloudformation describe-stack-events --stack-name={envname}')
+        for event in reversed(result['StackEvents']):
+            if update and event['Timestamp'] <= last_event_timestamp:
+                continue
+
+            if event['EventId'] in previously_seen:
+                continue
+            else:
+                if not event['ResourceStatus'].endswith('IN_PROGRESS'):
+                    logging.info('Provisioning event: %s %s',
+                                 event['LogicalResourceId'] if event['ResourceType'] != 'AWS::CloudFormation::Stack' else f'CloudLab {envname}',
+                                 event['ResourceStatus'])
+
+                previously_seen[event['EventId']] = event
+                if event['ResourceType'] == 'AWS::CloudFormation::Stack' and event['ResourceStatus'].find('COMPLETE') >= 0:
+                    done = True
+
+    result = runaws(f'aws cloudformation describe-stacks --stack-name={envname}')
+    status = result['Stacks'][0]['StackStatus']
+
+    if update:
+        if not status.startswith('UPDATE_COMPLETE'):
+            sys.exit('There was a failure while updating the CloudFormation stack.')
+        else:
+            logging.info('Cloud formation stack updated.')
+
+    else:
+        if status != 'CREATE_COMPLETE':
+            sys.exit('There was a failure while creating the CloudFormation stack.')
+        else:
+            logging.info('Cloud formation stack created.')
+
+    # build the inventory
+    inventory = {
+        "all": {
+            "vars": {
+                "ansible_ssh_private_key_file": envname + ".pem"
+            }
+        }
+    }
+
+    for subnet in config['subnets']:
+        for group in subnet['servers']:
+            role = group['role']
+            for ip_suffix in group['private_ip_suffixes']:
+                server_lookup_key = f"Instance{subnet['az'].upper()}{ip_suffix}Attributes"
+                attributes = get_cf_output(result, server_lookup_key).split('|')
+                public_ip = attributes[0]
+                private_ip = attributes[1]
+                # dns_name = attributes[2]
+
+                inv_role = inventory.setdefault(role, {
+                    'vars': {
+                        'ansible_user': config['roles'][role]['ssh_user']
+                    },
+                    'hosts': {}
+                })
+
+                inv_role['hosts'][public_ip] = {
+                    'private_ip': private_ip
+                }
+
+    invfile = os.path.join(envdir, 'inventory.yaml')
+    with open(invfile, 'w') as f:
+        yaml.dump(inventory, f)
+
+    logging.info('Wrote inventory to {}'.format(invfile))
+
+# returns public_ip, private_ip
+def get_cf_output(cf_cmd_result, key):
+    result = None
+    for output in cf_cmd_result['Stacks'][0]['Outputs']:
+        if output['OutputKey'] == key:
+            result = output['OutputValue']
+            break
+
+    return result
+
+# automatically appends --region= --output=json
+def runaws(commands):
+    cmdarray = commands.split()
+    cmdarray += ['--region={}'.format(config['region']), '--output=json']
+
+    result = subprocess.run(cmdarray, check=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+    if result.returncode != 0:
+        sys.exit(
+            'Exiting because an error occurred while running: {}.  The output was: {}'.format(' '.join(cmdarray),
+                                                                                              result.stdout))
+    if len(result.stdout) > 0:
+        return json.loads(result.stdout)
+    else:
+        return None
+
+# automatically appends --region= --output=json
+def runaws_result(commands):
+    cmdarray = commands.split()
+    cmdarray += ['--region={}'.format(config['region']), '--output=json']
+
+    return subprocess.run(cmdarray, check=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+# Parses cidr, extracts the first 3 octets, and appends suffix to then yielding a 4 octet IP
+def make_ip(cidr, suffix):
+    cidr_re = r'(\d{1,3}\.\d{1,3}\.\d{1,3})\.\d{1,3}/\d{2}'
+    suffix_re = r'\d{1,3}'
+    match = re.fullmatch(cidr_re, cidr)
+    if match is None:
+        raise SyntaxError(f'cidr "{cidr}" does not have the expected format.')
+
+    suffix = str(suffix)
+    if re.fullmatch(suffix_re, suffix) is None:
+        raise SyntaxError(f'suffix "{suffix}" does not have the expected format.')
+
+    return f'{match.group(1)}.{suffix}'

cloudlab/plans/aws_with_subnets.yaml.j2

@@ -0,0 +1,147 @@
+---
+  AWSTemplateFormatVersion: 2010-09-09
+  Description: "CloudLab {{ config.key_pair_name }}"
+
+  Resources:
+    VPC:
+      Type: AWS::EC2::VPC
+      Properties:
+        CidrBlock: {{ config.cidr }}
+        EnableDnsSupport: true
+        EnableDnsHostnames: true
+        InstanceTenancy: default
+
+    InternetGateway:
+      Type: AWS::EC2::InternetGateway
+
+    GatewayAttachment:
+      Type: AWS::EC2::VPCGatewayAttachment
+      Properties:
+        VpcId: !Ref VPC
+        InternetGatewayId: !Ref InternetGateway
+
+    MainRouteTable:
+      Type: AWS::EC2::RouteTable
+      Properties:
+        VpcId: !Ref VPC
+
+    NonLocalRoute:
+      Type: AWS::EC2::Route
+      Properties:
+        DestinationCidrBlock: 0.0.0.0/0
+        RouteTableId: !Ref MainRouteTable
+        GatewayId: !Ref InternetGateway
+      DependsOn: InternetGateway
+
+{% for subnet in config.subnets %}
+    Subnet{{ subnet.az|upper }}:
+      Type: AWS::EC2::Subnet
+      Properties:
+        CidrBlock: {{ subnet.cidr }}
+        VpcId: !Ref VPC
+
+    Subnet{{ subnet.az|upper }}RouteTableAssociation:
+      Type: AWS::EC2::SubnetRouteTableAssociation
+      Properties:
+        RouteTableId: !Ref MainRouteTable
+        SubnetId: !Ref Subnet{{ subnet.az|upper }}
+{% endfor %}
+
+    BaseSecurityGroup:
+      Type: AWS::EC2::SecurityGroup
+      Properties:
+        GroupDescription: Allow SSH
+        VpcId: !Ref VPC
+
+    SSHIngressRule:
+      Type: AWS::EC2::SecurityGroupIngress
+      Properties:
+        GroupId: !Ref BaseSecurityGroup
+        IpProtocol: tcp
+        FromPort: 22
+        ToPort: 22
+        CidrIp: 0.0.0.0/0
+
+    VPCIngressRule:
+      Type: AWS::EC2::SecurityGroupIngress
+      Properties:
+        GroupId: !Ref BaseSecurityGroup
+        IpProtocol: -1
+        CidrIp: {{ config.cidr }}
+
+    AllEgressRule:
+      Type: AWS::EC2::SecurityGroupEgress
+      Properties:
+        GroupId: !Ref BaseSecurityGroup
+        IpProtocol: -1
+        CidrIp: 0.0.0.0/0
+
+{% for role_name, role in config.roles.items() %}
+    {{ role_name }}SecurityGroup:
+      Type: AWS::EC2::SecurityGroup
+      Properties:
+        GroupDescription: Ingress rules for {{ role_name }}
+        VpcId: !Ref VPC
+
+    {% for port in role.open_ports %}
+    {{ role_name }}Port{{ port }}IngressRule:
+      Type: AWS::EC2::SecurityGroupIngress
+      Properties:
+        GroupId: !Ref {{ role_name }}SecurityGroup
+        IpProtocol: tcp
+        FromPort: {{ port }}
+        ToPort: {{ port }}
+        CidrIp: 0.0.0.0/0
+    {% endfor %}
+{% endfor %}
+
+{% for subnet in config.subnets %}
+    {% for group in subnet.servers %}
+        {% for private_ip_suffix in group.private_ip_suffixes %}
+    Instance{{ subnet.az|upper }}{{ private_ip_suffix }}:
+      Type: AWS::EC2::Instance
+      Properties:
+        DisableApiTermination: false
+        InstanceInitiatedShutdownBehavior: stop
+       {% if config.roles[group.role].ami_id  %}
+        ImageId: {{ config.roles[group.role].ami_id }}
+       {% else %}
+        ImageId: '{% raw %}{{resolve:ssm:{% endraw %}{{ config.roles[group.role].ami_name }}{% raw %}}}{% endraw %}'
+       {% endif %}
+        InstanceType: {{ config.roles[group.role].instance_type }}
+        KeyName: {{ config.key_pair_name }}
+        Monitoring: false
+        NetworkInterfaces:
+          - DeleteOnTermination: true
+            Description: primary network interface
+            DeviceIndex: 0
+            SubnetId: !Ref Subnet{{ subnet.az|upper }}
+            PrivateIpAddress: {{ group.private_ip_addresses[loop.index0] }}
+            GroupSet:
+              - !Ref BaseSecurityGroup
+              - !Ref {{ group.role }}SecurityGroup
+            AssociatePublicIpAddress: true
+        {% endfor %}
+    {% endfor %}
+{% endfor %}
+
+  Outputs:
+{% for subnet in config.subnets %}
+    {% for group in subnet.servers %}
+        {% for private_ip in group.private_ip_suffixes %}
+    Instance{{ subnet.az|upper }}{{ private_ip }}Attributes:
+        Description: The attributes of instance {{ subnet.az|upper }}{{ private_ip }}.
+        Value: !Join
+            - '|'
+            - - !GetAtt
+                - Instance{{ subnet.az|upper }}{{ private_ip }}
+                - PublicIp
+              - !GetAtt
+                - Instance{{ subnet.az|upper }}{{ private_ip }}
+                - PrivateIp
+              - !GetAtt
+                - Instance{{ subnet.az|upper }}{{ private_ip }}
+                - PublicDnsName
+        {% endfor %}
+    {% endfor %}
+{% endfor %}

cloudlab/resources/cloudlab_config.yaml

@@ -0,0 +1,45 @@
+# This example create a vpc with 2 subnets, one in us-east-2a and one in us-east-2b.  There are
+# 2 types of machines, which are listed under "roles": a ClusterMember and a LoadGenerator.  Roles can have
+# any name you choose so long as they do not contain spaces or special characters.  The  instance type, ami and
+# other details are specified under the role.
+#
+# AMIs can be specified with either ami_id or ami_name.  The ami_id is the Amazon image id, which is *region specific*.
+# A region agnostic approach is supported via ssm parameters.  If ami_id is not provided, then the ami_name will be
+# used to look up the image id for the region you are in.
+#
+# See https://medium.com/@josiahsicad/list-of-ec2-image-public-ssm-parameters-3338f83d4ec8 for an explanation of
+# how to look up SSM parameters for various operating systems. This sample illustrates both approaches.
+#
+# Number of instances of each type, and placement within subnets is specified under "subnets". In the example
+# below, 2 instances of the ClusterMember type will be placed in us-east-2a and will have IP addresses
+# 10.0.1.101 and 10.0.1.102.  The us-east-2b region will contain 2 more ClusterMember instances at
+# 10.0.2.101 and 10.0.2.102, and a LoadGenerator instance at 10.0.2.201
+#
+---
+region: us-east-2
+cidr: 10.0.0.0/16  # must be a /16 subnet, must be a non-routable IP (e.g. 10.*.*.*, 192.168.*.*)
+roles:
+  ClusterMember:   # role names are copied directly into the CloudFormation template and should not contain special characters
+    instance_type: m5.xlarge
+    ami_name: /aws/service/canonical/ubuntu/server/xenial/stable/current/amd64/hvm/ebs-gp2/ami-id
+    ssh_user: ubuntu
+    open_ports: [5701, 5702]
+  LoadGenerator:
+    instance_type: m5.xlarge
+    ami_name: /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64  # wont be used when ami_id is present
+    ami_id: ami-05efc83cb5512477c    # note this is region specific
+    ssh_user: ec2-user
+    open_ports: [8080]
+subnets:
+  - az: a                  # will be appended to region, e.g. us-east-2a
+    cidr: 10.0.1.0/24      # must be a /24
+    servers:
+      - private_ip_suffixes: [101, 102]   # only need to give the last octet, becomes 10.0.1.101
+        role: ClusterMember
+  - az: b
+    cidr: 10.0.2.0/24
+    servers:
+      - private_ip_suffixes: [101, 102]   # creates 2 servers, 10.0.2.101 and 10.0.2.102
+        role: ClusterMember
+      - private_ip_suffixes: [201]
+        role: LoadGenerator

cloudlab-1.2.2.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: cloudlab
+Version: 1.2.2
+Summary: A tool for provisioning lab environments on AWS
+Author: Randy May
+Author-email: randy@mathysphere.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: jinja2 (>=3.1.4)
+Requires-Dist: pyyaml (>=6.0.2)
+Description-Content-Type: text/markdown
+
+# Cloudlab Overview
+
+Cloudlab allows you to quickly provision a lab environment on AWS.  It attempts to strike a good balance between 
+configurability and ease of use by adopting a somewhat opinionated approach.
+
+Cloudlab provisions a single VPC on AWS with a /16 private address space.  Within the VPC, 1 or more subnets can be 
+configured.  All subnets are public and all have their own /24 address space inside the VPC.  All machines are assigned 
+a role.  The machine type, image and a list of open ports are configured at the role level to avoid redundant 
+configuration.
+
+After successful deployment, cloudlab writes an `inventory.yaml` file,  which list the public and private ips of all 
+servers, grouped by role.  The inventory file is suitable for use with Ansible.
+
+A sample configuration for deploying 5 servers to 2 subnets is shown below.
+```yaml
+---
+region: us-east-2
+cidr: 10.0.0.0/16  # must be a /16 subnet, must be a non-routable IP (e.g. 10.*.*.*, 192.168.*.*)
+roles:
+  ClusterMember:   # role names are copied directly into the CloudFormation template and should not contain special characters
+    instance_type: m5.xlarge
+    ami_name: /aws/service/canonical/ubuntu/server/xenial/stable/current/amd64/hvm/ebs-gp2/ami-id
+    ssh_user: ubuntu
+    open_ports: [5701, 5702]
+  LoadGenerator:
+    instance_type: m5.xlarge
+    ami_name: /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64  # wont be used when ami_id is present
+    ami_id: ami-05efc83cb5512477c    # note this is region specific
+    ssh_user: ec2-user
+    open_ports: [8080]
+subnets:
+  - az: a                  # will be appended to region, e.g. us-east-2a
+    cidr: 10.0.1.0/24      # must be a /24
+    servers:
+      - private_ip_suffixes: [101, 102]   # only need to give the last octet, becomes 10.0.1.101
+        role: ClusterMember
+  - az: b
+    cidr: 10.0.2.0/24
+    servers:
+      - private_ip_suffixes: [101, 102]   # creates 2 servers, 10.0.2.101 and 10.0.2.102
+        role: ClusterMember
+      - private_ip_suffixes: [201]
+        role: LoadGenerator
+```
+
+Other Notes:
+- All instances (hosts) will have an Amazon assigned public IP address and DNS name.
+- All hosts can initiate outbound connections to any other server either in or outside of the VPC
+- All hosts can receive connections on any port, from any other server in the VPC
+- All hosts accept inbound connections on port 22
+- Other than port 22, hosts will only accept inbound connections on specific ports which can be configured per role
+- Each environment provisioned with cloudlab will have its own ssh key which will be shared by all the hosts.
+- AMIs can be specified either with "ami_id", which is the region specific image id, or by "ami_name", which is 
+actually a public ssm parameter which is mapped to the correct id in each environment. For example: 
+"/aws/service/canonical/ubuntu/server/xenial/stable/current/amd64/hvm/ebs-gp2/ami-id".  For help finding the 
+SSM parameter for a certain image, see [this article](https://medium.com/@josiahsicad/list-of-ec2-image-public-ssm-parameters-3338f83d4ec8).
+
+# Setup
+
+Cloudlab requires python 3.10+.  
+
+It can be installed using pip.
+
+```
+pip install cloudlab
+```
+
+Cloudlab requires the aws cli to be present.  See https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html 
+for installation instructions.
+
+The AWS CLI will need to be configured with your credentials so it can access your AWS account.
+If your aws cli is not already configured, provide your credentials using the `aws configure` command or, 
+if sso is configured, `aws sso login`
+
+Cloudlab will have whatever privileges your cli has.  The snippet below is an IAM policy describing the permissions
+needed by cloudlab.
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Action": [
+                "ec2:*",
+                "cloudformation:*",
+                "elasticloudbalancing:*"
+            ],
+            "Effect": "Allow",
+            "Resource": "*"
+        }
+    ]
+}
+```
+
+# Usage
+
+## Define your environment
+Create a file called "cloudlab_config.yaml" in the current directory and edit it to describe the environment you
+would like to provision.  See the example above.  You can also create a sample configuration file by running 
+`cloudlab sample > cloudlab_config.yaml`.  See the comments in the sample file for details.
+
+## Create a new environment
+
+```
+cloudlab mkenv <envdir>
+```
+
+"envdir" should be an absolute or relative path.  The name of the directory, without any path,  will be used as the 
+name of the environment and the name must be unique. The "envdir" directory will be created.  The process 
+will fail if the directory exists.
+
+You can generate a CloudFormation template and skip the provisioning step by adding the `--no-provision` flag as 
+shown below.
+
+```
+cloudlab mkenv <envdir> --no-provision 
+```
+## Destroy an environment
+
+```
+cloudlab rmenv <envdir>
+```
+
+This command is idempotent.  It will not fail if the environment does not exist.
+
+## Update an environment
+
+Update `cloudlab_config.yaml` with your changes and run ...
+
+```
+cloudlab update <envdir>
+```
+
+# Release Notes
+
+## v1.2.2
+- Converted to Poetry build system 
+- Use SSM parameters for AMI ids.  
+
+## v1.2.1 - includes an important fix to the inventory file 
+- Fix to correct the format used for variables in the Ansible inventory file
+- Added a validation that the environment name is also a valid CloudFormation stack name
+
+## v1.2.0 is a major update
+- default plan now includes multiple subnets
+- configuration format has changed to allow the specification of subnets 
+- the `--plan` option allows alternate templates to be used although there currently are none.
+- the `cloudlab sample` will output a sample configuration file
+- removed dependency on methods in setuptools
+
+## v1.1.9
+
+- updated required verision of PyYAML to >= 5.4 to avoid known vulnerability in earlier versions.
+
+## v1.1.8
+
+- tplate updates broke cloudlab. The tplate version is now pinned to 1.0.3.
+
+## v1.1.7
+
+- Due to a limitation of 60 outputs in an AWS CloudFormation template, it was
+  not possible to provision more than 20 servers using cloudlab.  With this
+  update, the limit has been raised to 60 servers.
+
+## v1.1.6
+
+- fix for failing "update" command
+
+## v1.1.5
+
+- fixed a bug that caused mkenv to fail
+
+## v1.1.4
+
+- added the "update" command
+

cloudlab-1.2.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+cloudlab/__init__.py,sha256=z2CnkAUf9davrLieLZYsV237Ns0FNG-L5UAknrvfMGs,35
+cloudlab/commandline.py,sha256=uWFEgOx9PLPCutUH5dtZ6lac5-ZiPeLrnCkWfJ6094U,10916
+cloudlab/plans/aws_with_subnets.yaml.j2,sha256=rJkzfW8NWTqqaszRdny3IJ_MEOi_rFybI05vMYmun3I,4429
+cloudlab/resources/cloudlab_config.yaml,sha256=dLCXGmtpAhUgBNyrKQ_9JvR6AUki5stLjAtOJw0VDpA,2467
+cloudlab-1.2.2.dist-info/METADATA,sha256=0Yc_KjRaKswK1CdXBM0lNAEKMAdbYiok7bwm9sxBAg0,6970
+cloudlab-1.2.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cloudlab-1.2.2.dist-info/entry_points.txt,sha256=xC28NOEc2iIilrCyfCjovTtGtDgSjl01N8BNXglx-aI,53
+cloudlab-1.2.2.dist-info/RECORD,,

cloudlab-1.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cloudlab-1.2.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cloudlab=cloudlab.commandline:run
+