1. OpenStack Heat
Virtual Private Cloud (VPC) Resources

2. 1) List of VPC APIs implemented in Heat
a) CreateVPC == Create Virtual Network
b) CreateSubnet == Create Subnet in Virtual Network(VPC)
c) CreateInternetGateway == Get external network defined in the
Project
d) AttachInternetGateway == Connect external network to routers in
the Virtual Network(VPC)
e) CreateRouteTable == Create a router and attach to Virtual
Network(VPC)
f) AssociateRouteTable == Attach subnet to router
g) CreateEIP == Attach floating ip to instance

3. 2) Resource
heat/heat/engine/resource.py
class Resource(object):
@scheduler.wrappertask
def create(self):
'''
Create the resource. Subclasses should provide a handle_create() method
to customise creation.
'''
@scheduler.wrappertask
def update(self, after, before=None, prev_resource=None):
'''
update the resource. Subclasses should provide a handle_update()
method
to customise update, the base-class handle_update will fail by default.
'''
def resource_id_set(self, inst):
self.resource_id = inst

4. OpenStack Training Videos
Play Training Videos
https://www.youtube.com/user/sajuptpm/videos

5. Continue ...
def action_handler_task(self, action, args=[], action_prefix=None):
'''
A task to call the Resource subclass's handler methods for an action.
Calls the handle_<ACTION>() method for the given action and then calls
the check_<ACTION>_complete() method with the result in a loop until it
returns True. If the methods are not provided, the call is omitted.
Any args provided are passed to the handler.
If a prefix is supplied, the handler method handle_<PREFIX>_<ACTION>()
is called instead.
'''
def physical_resource_name(self):
name = '%s-%s-%s' % (self.stack.name,
self.name,
short_id.get_id(self.id))
return name
def neutron(self):
return self.client('neutron')

6. 3) VPC Resource
heat/heat/engine/resources/vpc.py
class VPC(resource.Resource):
PROPERTIES = (
CIDR_BLOCK, INSTANCE_TENANCY, TAGS,
) = (
'CidrBlock', 'InstanceTenancy', 'Tags',
)
properties_schema = { .... }
def handle_create(self):
client = self.neutron()
# The VPC's net and router are associated by having identical names.
net_props = {'name': self.physical_resource_name()}
router_props = {'name': self.physical_resource_name()}
net = client.create_network({'network': net_props})['network']
self.resource_id_set(net['id'])
client.create_router({'router': router_props})['router']

7. Continue ...
def check_create_complete(self, *args):
....
def handle_delete(self):
....
def resource_mapping():
return {
'AWS::EC2::VPC': VPC,
}

8. 4) Subnet Resource
heat/heat/engine/resources/subnet.py
class Subnet(resource.Resource):
PROPERTIES = (
AVAILABILITY_ZONE, CIDR_BLOCK, VPC_ID, TAGS,
) = (
'AvailabilityZone', 'CidrBlock', 'VpcId', 'Tags',
)
properties_schema = { .... }
def handle_delete(self):
....
def resource_mapping():
return {
'AWS::EC2::Subnet': Subnet,
}

9. Continue ...
def handle_create(self):
client = self.neutron()
# TODO(sbaker) Verify that this CidrBlock is within the vpc CidrBlock
network_id = self.properties.get(self.VPC_ID)
props = {
'network_id': network_id,
'cidr': self.properties.get(self.CIDR_BLOCK),
'name': self.physical_resource_name(),
'ip_version': 4
}
subnet = client.create_subnet({'subnet': props})['subnet']
self.resource_id_set(subnet['id'])
router = vpc.VPC.router_for_vpc(self.neutron(), network_id)
if router:
client.add_interface_router(
router['id'],
{'subnet_id': subnet['id']})

10. 5) RouteTable Resource
heat/heat/engine/resources/route_table.py
class RouteTable(resource.Resource):
PROPERTIES = (
VPC_ID, TAGS,
) = (
'VpcId', 'Tags',
)
properties_schema = { .... }
def handle_create(self):
client = self.client()
props = {'name': self.physical_resource_name()}
router = client.create_router({'router': props})['router']
self.resource_id_set(router['id'])
def resource_mapping():
return {
'AWS::EC2::RouteTable': RouteTable
}

11. 6) SubnetRouteTableAssociation Resource
heat/heat/engine/resources/route_table.py
class SubnetRouteTableAssociation(resource.Resource):
PROPERTIES = (ROUTE_TABLE_ID, SUBNET_ID,) = ( 'RouteTableId', 'SubnetId',)
properties_schema = { .... }
def handle_create(self):
client = self.client()
subnet_id = self.properties.get(self.SUBNET_ID)
router_id = self.properties.get(self.ROUTE_TABLE_ID)
#remove the default router association for this subnet.
try:
previous_router = self._router_for_subnet(subnet_id)
if previous_router:
client.remove_interface_router(
previous_router['id'],
{'subnet_id': subnet_id})
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
client.add_interface_router(
router_id, {'subnet_id': subnet_id})
def resource_mapping():
return {
'AWS::EC2::SubnetRouteTableAssociation': SubnetRouteTableAssociation,
}

12. 7) InternetGateway Resource
heat/heat/engine/resources/internet_gateway.py
class InternetGateway(resource.Resource):
PROPERTIES = (TAGS,) = ('Tags',)
properties_schema = { .... }
def handle_create(self):
self.resource_id_set(self.physical_resource_name())
@staticmethod
def get_external_network_id(client):
ext_filter = {'router:external': True}
ext_nets = client.list_networks(**ext_filter)['networks']
if len(ext_nets) != 1:
raise exception.Error(
_('Expected 1 external network, found %d') % len(ext_nets))
external_network_id = ext_nets[0]['id']
return external_network_id
def resource_mapping():
return {
'AWS::EC2::InternetGateway': InternetGateway,
}

13. 8) VPCGatewayAttachment Resource
heat/heat/engine/resources/internet_gateway.py
class VPCGatewayAttachment(resource.Resource):
PROPERTIES = (
VPC_ID, INTERNET_GATEWAY_ID, VPN_GATEWAY_ID,
) = ( 'VpcId', 'InternetGatewayId', 'VpnGatewayId',)
properties_schema = { .... }
def handle_create(self):
client = self.neutron()
external_network_id = InternetGateway.get_external_network_id(client)
for router in self._vpc_route_tables():
client.add_gateway_router(router.resource_id, {
'network_id': external_network_id})
def resource_mapping():
return {
'AWS::EC2::VPCGatewayAttachment': VPCGatewayAttachment,
}

14. 9) ElasticIp Resource
heat/heat/engine/resources/eip.py
class ElasticIp(resource.Resource):
PROPERTIES = (DOMAIN, INSTANCE_ID,) = ('Domain', 'InstanceId', )
properties_schema = { .... }
def handle_create(self):
"""Allocate a floating IP for the current tenant."""
ips = None
if self.properties[self.DOMAIN]:
from heat.engine.resources import internet_gateway
ext_net = internet_gateway.InternetGateway.get_external_network_id(self.neutron())
props = {'floating_network_id': ext_net}
ips = self.neutron().create_floatingip({
'floatingip': props})['floatingip']
self.ipaddress = ips['floating_ip_address']
self.resource_id_set(ips['id'])
instance_id = self.properties[self.INSTANCE_ID]
if instance_id:
server = self.nova().servers.get(instance_id)
server.add_floating_ip(self._ipaddress())
def resource_mapping():
return {
'AWS::EC2::EIP': ElasticIp,
}

15. 10) ElasticIpAssociation Resource
heat/heat/engine/resources/eip.py
class ElasticIpAssociation(resource.Resource):
PROPERTIES = (
INSTANCE_ID, EIP, ALLOCATION_ID, NETWORK_INTERFACE_ID,
) = (
'InstanceId', 'EIP', 'AllocationId', 'NetworkInterfaceId',
)
properties_schema = { .... }
def handle_create(self):
"""Add a floating IP address to a server."""
if self.properties[self.EIP]:
server = self.nova().servers.get(self.properties[self.INSTANCE_ID])
server.add_floating_ip(self.properties[self.EIP])
self.resource_id_set(self.properties[self.EIP])
def resource_mapping():
return {
'AWS::EC2::EIPAssociation': ElasticIpAssociation,
}

16. 11) VPC UnitTest
heat/heat/tests/test_vpc.py
class VPCTestBase(common.HeatTestCase):
class VPCTest(VPCTestBase):
class SubnetTest(VPCTestBase):
class NetworkInterfaceTest(VPCTestBase):
class InternetGatewayTest(VPCTestBase):
class RouteTableTest(VPCTestBase):

17. 12) ElasticIp UnitTest
heat/heat/tests/test_eip.py
class EIPTest(common.HeatTestCase):
class AllocTest(common.HeatTestCase):

18. Thanks
● Email: sajuptpm@gmail.com
● Training Videos: https://www.youtube.com/user/sajuptpm/videos
● WebSite: http://fosshelp.blogspot.in
● IRC: saju_m
● Skype: sajuptpm