private static async Task <BootVolume> createBootVolume(BlockstorageClient blockstorageClient, string compartmentId, AvailabilityDomain availabilityDomain, Image image)
{
string bootVolumeName = "oci-dotnet-sdk-example-boot-volume";
// find existing boot volume by image
ListBootVolumesRequest listBootVolumesRequest = new ListBootVolumesRequest
{
AvailabilityDomain = availabilityDomain.Name,
CompartmentId = compartmentId
};
ListBootVolumesResponse listBootVolumesResponse = await blockstorageClient.ListBootVolumes(listBootVolumesRequest);
List <BootVolume> bootVolumes = listBootVolumesResponse.Items;
BootVolume existingBootVolume = null;
foreach (BootVolume bootVol in bootVolumes)
{
if (BootVolume.LifecycleStateEnum.Available.Equals(bootVol.LifecycleState) && image.Id.Equals(bootVol.ImageId))
{
existingBootVolume = bootVol;
break;
}
}
// create a new boot volume based on existing one
logger.Info($"Found BootVolume: {existingBootVolume.Id}");
BootVolumeSourceDetails existingBootVolumeDetails = existingBootVolume.SourceDetails;
BootVolumeSourceDetails bootVolumeSourceDetails = new BootVolumeSourceFromBootVolumeDetails
{
Id = existingBootVolume.Id
};
CreateBootVolumeDetails createBootVolumeDetails = new CreateBootVolumeDetails
{
AvailabilityDomain = availabilityDomain.Name,
CompartmentId = compartmentId,
DisplayName = bootVolumeName,
SourceDetails = bootVolumeSourceDetails
};
CreateBootVolumeRequest createBootVolumeRequest = new CreateBootVolumeRequest {
CreateBootVolumeDetails = createBootVolumeDetails
};
CreateBootVolumeResponse createBootVolumeResponse = await blockstorageClient.CreateBootVolume(createBootVolumeRequest);
logger.Info($"Provisioning new BootVolume: " + createBootVolumeResponse.BootVolume.Id);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
// wait for boot volume to be ready
GetBootVolumeRequest getBootVolumeRequest = new GetBootVolumeRequest {
BootVolumeId = createBootVolumeResponse.BootVolume.Id
};
GetBootVolumeResponse getBootVolumeResponse = blockstorageClient.Waiters.ForBootVolume(getBootVolumeRequest, waiterConfiguration, BootVolume.LifecycleStateEnum.Available).Execute();
BootVolume bootVolume = getBootVolumeResponse.BootVolume;
logger.Info($"Provisioned BootVolume: {bootVolume.Id}");
return(bootVolume);
}
private static LaunchInstanceDetails createLaunchInstanceDetailsFromBootVolume(LaunchInstanceDetails launchInstanceDetails, BootVolume bootVolume)
{
InstanceSourceViaBootVolumeDetails instanceSourceViaBootVolumeDetails = new InstanceSourceViaBootVolumeDetails
{
BootVolumeId = bootVolume.Id
};
LaunchInstanceAgentConfigDetails launchInstanceAgentConfigDetails = new LaunchInstanceAgentConfigDetails
{
IsMonitoringDisabled = true
};
return(new LaunchInstanceDetails
{
AvailabilityDomain = launchInstanceDetails.AvailabilityDomain,
CompartmentId = launchInstanceDetails.CompartmentId,
Shape = launchInstanceDetails.Shape,
CreateVnicDetails = launchInstanceDetails.CreateVnicDetails,
ImageId = launchInstanceDetails.ImageId,
SourceDetails = instanceSourceViaBootVolumeDetails,
AgentConfig = launchInstanceAgentConfigDetails
});
}
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");
}
}
