func createInternalVirtualNetwork(
client network.ManagementClient,
controllerResourceGroup string,
location string,
tags map[string]string,
) (*network.VirtualNetwork, error) {
addressPrefixes := make([]string, 256)
for i := range addressPrefixes {
addressPrefixes[i] = fmt.Sprintf("10.%d.0.0/16", i)
}
virtualNetworkParams := network.VirtualNetwork{
Location: to.StringPtr(location),
Tags: toTagsPtr(tags),
Properties: &network.VirtualNetworkPropertiesFormat{
AddressSpace: &network.AddressSpace{&addressPrefixes},
},
}
logger.Debugf("creating virtual network %q", internalNetworkName)
vnetClient := network.VirtualNetworksClient{client}
vnet, err := vnetClient.CreateOrUpdate(
controllerResourceGroup, internalNetworkName, virtualNetworkParams,
)
if err != nil {
return nil, errors.Annotatef(err, "creating virtual network %q", internalNetworkName)
}
return &vnet, nil
}
// initResourceGroup creates and initialises a resource group for this
// environment. The resource group will have a storage account and a
// subnet associated with it (but not necessarily contained within:
// see subnet creation).
func (env *azureEnviron) initResourceGroup() (*config.Config, error) {
location := env.config.location
tags, _ := env.config.ResourceTags()
resourceGroupsClient := resources.GroupsClient{env.resources}
logger.Debugf("creating resource group %q", env.resourceGroup)
_, err := resourceGroupsClient.CreateOrUpdate(env.resourceGroup, resources.Group{
Location: to.StringPtr(location),
Tags: toTagsPtr(tags),
})
if err != nil {
return nil, errors.Annotate(err, "creating resource group")
}
var vnetPtr *network.VirtualNetwork
if env.resourceGroup == env.controllerResourceGroup {
// Create an internal network for all VMs to connect to.
vnetPtr, err = createInternalVirtualNetwork(
env.network, env.controllerResourceGroup, location, tags,
)
if err != nil {
return nil, errors.Annotate(err, "creating virtual network")
}
} else {
// We're creating a hosted environment, so we need to fetch
// the virtual network to create a subnet below.
vnetClient := network.VirtualNetworksClient{env.network}
vnet, err := vnetClient.Get(env.controllerResourceGroup, internalNetworkName)
if err != nil {
return nil, errors.Annotate(err, "getting virtual network")
}
vnetPtr = &vnet
}
_, err = createInternalSubnet(
env.network, env.resourceGroup, env.controllerResourceGroup,
vnetPtr, location, tags,
)
if err != nil {
return nil, errors.Annotate(err, "creating subnet")
}
// Create a storage account for the resource group.
storageAccountsClient := storage.AccountsClient{env.storage}
storageAccountName, storageAccountKey, err := createStorageAccount(
storageAccountsClient, env.config.storageAccountType,
env.resourceGroup, location, tags,
env.provider.config.StorageAccountNameGenerator,
)
if err != nil {
return nil, errors.Annotate(err, "creating storage account")
}
return env.config.Config.Apply(map[string]interface{}{
configAttrStorageAccount: storageAccountName,
configAttrStorageAccountKey: storageAccountKey,
})
}
