public void createModel(Package pkg, InternetGateway igw)
{
// Get the model identifier
string igwId = igw.InternetGatewayId.ToString();
// Create the Route Table element
Element element = pkg.Elements.AddNew(igwId, "Class");
element.Update();
// Keep it in the cache
this.AwsModelCache.Add(igwId, element);
}
public static Subnet CreateSubnet()
{
var vpc = new Vpc($"{Common.appName}-vpc", new VpcArgs()
{
EnableDnsHostnames = true,
EnableDnsSupport = true,
CidrBlock = $"{vpcCidrBase}.0/24",
Tags = Common.tags
});
var ig = new InternetGateway($"{Common.appName}-igw", new InternetGatewayArgs()
{
VpcId = vpc.Id,
Tags = Common.tags
});
var rt = new RouteTable($"{Common.appName}-rt", new RouteTableArgs()
{
VpcId = vpc.Id,
Tags = Common.tags
});
var subnet = new Subnet($"{Common.appName}-subnet", new SubnetArgs {
VpcId = vpc.Id,
CidrBlock = $"{vpcCidrBase}.0/25",
Tags = Common.tags
});
var rta = new RouteTableAssociation($"{Common.appName}-rta", new RouteTableAssociationArgs()
{
RouteTableId = rt.Id,
SubnetId = subnet.Id,
});
var drt = new DefaultRouteTable($"{Common.appName}-drt", new DefaultRouteTableArgs()
{
DefaultRouteTableId = rt.Id,
Routes = new InputList <DefaultRouteTableRouteArgs> {
new DefaultRouteTableRouteArgs()
{
CidrBlock = "0.0.0.0/0", GatewayId = ig.Id
}
},
Tags = Common.tags
});
return(subnet);
}
/**
* Create all the OCI and Fn resources required to invoke a function.
*
* @param provider the OCI credentials provider.
* @param compartmentId the compartment in which to create the required
* resources.
* @param image a valid OCI Registry image for the function.
*/
private static async Task SetUpResources(IBasicAuthenticationDetailsProvider provider, string compartmentId, string image)
{
logger.Info("Setting up resources");
var identityClient = new IdentityClient(provider);
var vcnClient = new VirtualNetworkClient(provider);
var fnManagementClient = new FunctionsManagementClient(provider);
Vcn vcn = null;
Subnet subnet = null;
InternetGateway internetGateway = null;
try
{
AvailabilityDomain availablityDomain = await GetAvailabilityDomain(identityClient, compartmentId);
logger.Info($"availability domain is {availablityDomain.Name}");
vcn = await CreateVcn(vcnClient, compartmentId);
internetGateway = await CreateInternalGateway(vcnClient, compartmentId, vcn);
await AddInternetGatewayToDefaultRouteTable(vcnClient, vcn.DefaultRouteTableId, internetGateway.Id);
subnet = await CreateSubnet(vcnClient, compartmentId, availablityDomain.Name, vcn.Id);
var subnetIds = new List <string>()
{
subnet.Id
};
Application app = await CreateApplication(fnManagementClient, compartmentId, subnetIds);
long memoryInMBs = 128L;
int timeoutInSeconds = 30;
Function fn = await CreateFunction(fnManagementClient, app.Id, image, memoryInMBs, timeoutInSeconds);
}
catch (Exception e)
{
logger.Error($"failed to setup resources: {e}");
}
finally
{
fnManagementClient.Dispose();
vcnClient.Dispose();
identityClient.Dispose();
}
}
private static async Task <InternetGateway> CreateInternalGateway(VirtualNetworkClient vcnClient, string compartmentId, Vcn vcn)
{
CreateInternetGatewayDetails createInternetGatewayDetails = new CreateInternetGatewayDetails
{
CompartmentId = compartmentId,
DisplayName = IgName,
IsEnabled = true,
VcnId = vcn.Id
};
CreateInternetGatewayRequest createInternetGatewayRequest = new CreateInternetGatewayRequest {
CreateInternetGatewayDetails = createInternetGatewayDetails
};
CreateInternetGatewayResponse createInternetGatewayResponse = await vcnClient.CreateInternetGateway(createInternetGatewayRequest);
GetInternetGatewayRequest getInternetGatewayRequest = new GetInternetGatewayRequest {
IgId = createInternetGatewayResponse.InternetGateway.Id
};
GetInternetGatewayResponse getInternetGatewayResponse = vcnClient.Waiters.ForInternetGateway(getInternetGatewayRequest, InternetGateway.LifecycleStateEnum.Available).Execute();
InternetGateway internetGateway = getInternetGatewayResponse.InternetGateway;
logger.Info($"Created internet gateway: {internetGateway.Id} and state is {internetGateway.LifecycleState}");
return(internetGateway);
}
private async Task <VpcData> Define()
{
var availabilityZonesResult = await GetAvailabilityZones.InvokeAsync(
null,
new InvokeOptions
{
Provider = _options?.Provider
});
var azA = availabilityZonesResult.Names[0];
var azB = availabilityZonesResult.Names[1];
var vpcResourceName = $"{GetResourceName()}";
var vpc = new Vpc(
vpcResourceName,
new VpcArgs
{
CidrBlock = $"10.{_args.CidrBlockSegment}.0.0/16",
Tags = new InputMap <string>
{
{ "Name", vpcResourceName },
{ "pulumi:ResourceName", vpcResourceName }
}
},
new CustomResourceOptions
{
Provider = _options?.Provider,
Parent = this
});
var private0 = AddSubnet(vpcResourceName, vpc, "private", azA, 0, _args.CidrBlockSegment, 0);
var private1 = AddSubnet(vpcResourceName, vpc, "private", azB, 1, _args.CidrBlockSegment, 64);
var public0 = AddSubnet(vpcResourceName, vpc, "public", azA, 0, _args.CidrBlockSegment, 128);
var public1 = AddSubnet(vpcResourceName, vpc, "public", azB, 1, _args.CidrBlockSegment, 192);
var ig = new InternetGateway(
$"{vpc.GetResourceName()}-ig",
new InternetGatewayArgs
{
VpcId = vpc.Id
},
new CustomResourceOptions
{
Parent = vpc
});
new Route($"{public0.RouteTable.GetResourceName()}-ig", new RouteArgs
{
RouteTableId = public0.RouteTable.Id,
DestinationCidrBlock = "0.0.0.0/0",
GatewayId = ig.Id
}, new CustomResourceOptions
{
Parent = public0.RouteTable
});
new Route($"{public1.RouteTable.GetResourceName()}-ig", new RouteArgs
{
RouteTableId = public1.RouteTable.Id,
DestinationCidrBlock = "0.0.0.0/0",
GatewayId = ig.Id
}, new CustomResourceOptions
{
Parent = public1.RouteTable
});
var eip0 = new Eip(
$"{public0.Subnet.GetResourceName()}-eip",
new EipArgs
{
Vpc = true,
Tags = new InputMap <string>
{
{ "Name", $"{public0.Subnet.GetResourceName()}-eip" }
}
},
new CustomResourceOptions
{
Parent = public0.Subnet
});
var natGateway0 = new NatGateway(
$"{public0.Subnet.GetResourceName()}-ng",
new NatGatewayArgs
{
SubnetId = public0.Subnet.Id,
AllocationId = eip0.Id,
Tags = new InputMap <string>
{
{ "Name", $"{public0.Subnet.GetResourceName()}-ng" }
}
},
new CustomResourceOptions
{
Parent = public0.Subnet
});
new Route($"{private0.Subnet.GetResourceName()}-nat-0", new RouteArgs
{
RouteTableId = private0.RouteTable.Id,
DestinationCidrBlock = "0.0.0.0/0",
NatGatewayId = natGateway0.Id
}, new CustomResourceOptions
{
Parent = private0.Subnet
});
var eip1 = new Eip(
$"{public1.Subnet.GetResourceName()}-eip",
new EipArgs
{
Vpc = true,
Tags = new InputMap <string>
{
{ "Name", $"{public1.Subnet.GetResourceName()}-eip" }
}
},
new CustomResourceOptions
{
Parent = public1.Subnet
});
var natGateway1 = new NatGateway(
$"{public1.Subnet.GetResourceName()}-ng",
new NatGatewayArgs
{
SubnetId = public1.Subnet.Id,
AllocationId = eip1.Id,
Tags = new InputMap <string>
{
{ "Name", $"{public1.Subnet.GetResourceName()}-ng" }
}
},
new CustomResourceOptions
{
Parent = public1.Subnet
});
new Route($"{private1.Subnet.GetResourceName()}-nat-1", new RouteArgs
{
RouteTableId = private1.RouteTable.Id,
DestinationCidrBlock = "0.0.0.0/0",
NatGatewayId = natGateway1.Id
}, new CustomResourceOptions
{
Parent = private1.Subnet
});
return(new VpcData(vpc, private0.Subnet, private1.Subnet, public0.Subnet, public1.Subnet));
}
private static async Task deleteInternetGateway(VirtualNetworkClient virtualNetworkClient, InternetGateway internetGateway)
{
DeleteInternetGatewayRequest deleteInternetGatewayRequest = new DeleteInternetGatewayRequest
{
IgId = internetGateway.Id
};
await virtualNetworkClient.DeleteInternetGateway(deleteInternetGatewayRequest);
logger.Info($"Deleted Internet Gateway: {internetGateway.Id}");
}
public static async Task MainInstance()
{
logger.Info("Starting example");
var provider = new ConfigFileAuthenticationDetailsProvider("DEFAULT");
var compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
var identityClient = new IdentityClient(provider);
var computeClient = new ComputeClient(provider, new ClientConfiguration());
var virtualNetworkClient = new VirtualNetworkClient(provider);
var blockStorageClient = new BlockstorageClient(provider);
var networkCidrBlock = "10.0.1.0/24";
LaunchInstanceDetails launchInstanceDetails = null;
Instance instance = null;
BootVolume bootVolume = null;
Instance instanceFromBootVolume = null;
Vcn vcn = null;
Subnet subnet = null;
CreateVnicDetails createVnicDetails = null;
InternetGateway internetGateway = null;
AvailabilityDomain availablityDomain = await getAvailabilityDomains(identityClient, compartmentId);
logger.Info($"availability domain is {availablityDomain.Name}");
Shape shape = await getShape(computeClient, compartmentId, availablityDomain);
if (shape == null)
{
logger.Error($"No Shapes available in the availability domain: {availablityDomain.Name}");
return;
}
logger.Info($"shape is {shape.ShapeProp}");
Image image = await getImage(computeClient, compartmentId, shape);
try
{
vcn = await createVcn(virtualNetworkClient, compartmentId, networkCidrBlock);
// The Internet Gateway with updated Route Rules will enable the instance to connect to the public
// internet. If it is not desired, remove the following two lines below that create an internet
// gateway and add that internet gateway to the VCN route table.
internetGateway = await createInternalGateway(virtualNetworkClient, compartmentId, vcn);
await addInternetGatewayToDefaultRouteTable(virtualNetworkClient, vcn, internetGateway);
subnet = await createSubnet(virtualNetworkClient, compartmentId, availablityDomain, networkCidrBlock, vcn);
createVnicDetails = new CreateVnicDetails {
SubnetId = subnet.Id
};
launchInstanceDetails = new LaunchInstanceDetails
{
AvailabilityDomain = availablityDomain.Name,
CompartmentId = compartmentId,
Shape = shape.ShapeProp,
CreateVnicDetails = createVnicDetails,
ImageId = image.Id
};
instance = await createInstance(computeClient, launchInstanceDetails);
await printInstance(computeClient, virtualNetworkClient, instance);
logger.Info("Instance is being created via boot volume ...");
// This boot volume is created based on the boot volume of previous instance which needs to be running
bootVolume = await createBootVolume(blockStorageClient, compartmentId, availablityDomain, image);
launchInstanceDetails = createLaunchInstanceDetailsFromBootVolume(launchInstanceDetails, bootVolume);
instanceFromBootVolume = await createInstance(computeClient, launchInstanceDetails);
await printInstance(computeClient, virtualNetworkClient, instanceFromBootVolume);
}
catch (Exception e)
{
logger.Error($"Failed to call LaunchInstance API: {e.Message}");
}
finally
{
logger.Info("cleaning up resources");
if (instanceFromBootVolume != null)
{
await terminateInstance(computeClient, instanceFromBootVolume);
}
if (instance != null)
{
await terminateInstance(computeClient, instance);
}
if (internetGateway != null)
{
await clearRouteRulesFromDefaultRouteTable(virtualNetworkClient, vcn);
await deleteInternetGateway(virtualNetworkClient, internetGateway);
}
if (subnet != null)
{
await deleteSubnet(virtualNetworkClient, subnet);
}
if (vcn != null)
{
await deleteVcn(virtualNetworkClient, vcn);
}
identityClient.Dispose();
computeClient.Dispose();
virtualNetworkClient.Dispose();
blockStorageClient.Dispose();
logger.Info("End example");
}
}
private static async Task addInternetGatewayToDefaultRouteTable(VirtualNetworkClient virtualNetworkClient, Vcn vcn, InternetGateway internetGateway)
{
GetRouteTableRequest getRouteTableRequest = new GetRouteTableRequest {
RtId = vcn.DefaultRouteTableId
};
GetRouteTableResponse getRouteTableResponse = await virtualNetworkClient.GetRouteTable(getRouteTableRequest);
var routeRules = getRouteTableResponse.RouteTable.RouteRules;
logger.Info("Current Route Rules in Default Route Table");
logger.Info("==========================================");
routeRules.ForEach(delegate(RouteRule rule)
{
logger.Info($"rule: {rule.NetworkEntityId}");
});
RouteRule internetAccessRoute = new RouteRule
{
Destination = "0.0.0.0/0",
DestinationType = RouteRule.DestinationTypeEnum.CidrBlock,
NetworkEntityId = internetGateway.Id
};
routeRules.Add(internetAccessRoute);
UpdateRouteTableDetails updateRouteTableDetails = new UpdateRouteTableDetails {
RouteRules = routeRules
};
UpdateRouteTableRequest updateRouteTableRequest = new UpdateRouteTableRequest
{
UpdateRouteTableDetails = updateRouteTableDetails,
RtId = vcn.DefaultRouteTableId
};
UpdateRouteTableResponse updateRouteTableResponse = await virtualNetworkClient.UpdateRouteTable(updateRouteTableRequest);
getRouteTableResponse = virtualNetworkClient.Waiters.ForRouteTable(getRouteTableRequest, RouteTable.LifecycleStateEnum.Available).Execute();
routeRules = getRouteTableResponse.RouteTable.RouteRules;
logger.Info("Updated Route Rules in Default Route Table");
logger.Info("==========================================");
routeRules.ForEach(delegate(RouteRule rule)
{
logger.Info($"rule: {rule.NetworkEntityId}\n");
});
}
public CreateInternetGatewayModelWorkItemImpl NewCreateInternetGatewayModelWorkItem(Package pkg, InternetGateway internetGateway)
{
CreateInternetGatewayModelWorkItemImpl workItem = new CreateInternetGatewayModelWorkItemImpl();
workItem.Pkg = pkg;
workItem.InternetGateway = internetGateway;
return(workItem);
}
