/// <summary>
/// create a default private endpoint for managed instance.
/// please make sure your MI built using CreateDefaultManagedInstance() or vnet AddressPrefixes = 10.10.0.0/16
/// </summary>
/// <param name="managedInstance"></param>
/// <param name="location"></param>
/// <param name="resourceGroup"></param>
/// <param name=""></param>
/// <returns></returns>
protected async Task <PrivateEndpoint> CreateDefaultPrivateEndpoint(ManagedInstance managedInstance, VirtualNetwork vnet, Location location, ResourceGroup resourceGroup)
{
// Add new subnet
SubnetData subnetData = new SubnetData()
{
AddressPrefix = "10.10.5.0/24",
PrivateEndpointNetworkPolicies = "Disabled"
};
var privateEndpointSubnet = await vnet.GetSubnets().CreateOrUpdateAsync($"private-endpoint-subnet", subnetData);
// Create private endpoint
string privateEndpointName = $"{managedInstance.Data.Name}-private-endpoint";
var endpointCollection = resourceGroup.GetPrivateEndpoints();
PrivateEndpointData data = new PrivateEndpointData()
{
Subnet = new SubnetData()
{
Id = privateEndpointSubnet.Value.Data.Id
},
Location = location,
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection()
{
Name = privateEndpointName,
PrivateLinkServiceId = managedInstance.Data.Id.ToString(),
GroupIds = { "managedInstance" },
}
},
};
var privateEndpoint = await resourceGroup.GetPrivateEndpoints().CreateOrUpdateAsync(privateEndpointName, data);
return(privateEndpoint.Value);
}
PrivateEndpoint IOperationSource <PrivateEndpoint> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = PrivateEndpointData.DeserializePrivateEndpointData(document.RootElement);
return(new PrivateEndpoint(_armClient, data));
}
internal static PrivateEndpointListResult DeserializePrivateEndpointListResult(JsonElement element)
{
Optional <IReadOnlyList <PrivateEndpointData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <PrivateEndpointData> array = new List <PrivateEndpointData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(PrivateEndpointData.DeserializePrivateEndpointData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new PrivateEndpointListResult(Optional.ToList(value), nextLink.Value));
}
internal PrivateEndpointConnection(string id, string name, string type, string etag, PrivateEndpointData privateEndpoint, PrivateLinkServiceConnectionState privateLinkServiceConnectionState, ProvisioningState?provisioningState, string linkIdentifier) : base(id)
{
Name = name;
Type = type;
Etag = etag;
PrivateEndpoint = privateEndpoint;
PrivateLinkServiceConnectionState = privateLinkServiceConnectionState;
ProvisioningState = provisioningState;
LinkIdentifier = linkIdentifier;
}
public async Task TestSetUp()
{
if (Mode == RecordedTestMode.Record || Mode == RecordedTestMode.Playback)
{
Initialize();
string groupName = Recording.GenerateAssetName(ResourceGroupPrefix);
string VnetName = Recording.GenerateAssetName("vnetname");
string SubnetName = Recording.GenerateAssetName("subnetname");
string EndpointName = Recording.GenerateAssetName("endpointxyz");
ResGroup = await(await ArmClient.GetDefaultSubscriptionAsync().Result.GetResourceGroups().CreateOrUpdateAsync(groupName, new ResourceGroupData(Location))).WaitForCompletionAsync();
string configurationStoreName = Recording.GenerateAssetName("testapp-");
ConfigurationStoreData configurationStoreData = new ConfigurationStoreData(Location, new Models.Sku("Standard"))
{
PublicNetworkAccess = PublicNetworkAccess.Disabled
};
ConfigStore = await(await ResGroup.GetConfigurationStores().CreateOrUpdateAsync(configurationStoreName, configurationStoreData)).WaitForCompletionAsync();
// Prepare VNet and Private Endpoint
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = "eastus",
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = SubnetName, AddressPrefix = "10.0.0.0/24", PrivateEndpointNetworkPolicies = "Disabled"
} }
};
VirtualNetwork vnet = await(await ResGroup.GetVirtualNetworks().CreateOrUpdateAsync(VnetName, vnetData)).WaitForCompletionAsync();
PrivateEndpointData privateEndpointData = new PrivateEndpointData()
{
Location = "eastus",
PrivateLinkServiceConnections = { new PrivateLinkServiceConnection()
{
Name = "myconnection",
PrivateLinkServiceId = ConfigStore.Data.Id,
GroupIds = { "configurationStores" },
RequestMessage = "Please approve my connection",
} },
Subnet = new SubnetData()
{
Id = "/subscriptions/" + TestEnvironment.SubscriptionId + "/resourceGroups/" + groupName + "/providers/Microsoft.Network/virtualNetworks/" + VnetName + "/subnets/" + SubnetName
}
};
PrivateEndpoint = await(await ResGroup.GetPrivateEndpoints().CreateOrUpdateAsync(EndpointName, privateEndpointData)).WaitForCompletionAsync();
List <PrivateEndpointConnection> connections = await ConfigStore.GetPrivateEndpointConnections().GetAllAsync().ToEnumerableAsync();
Connection = connections.FirstOrDefault();
}
}
public async Task TestSetUp()
{
if (Mode == RecordedTestMode.Record || Mode == RecordedTestMode.Playback)
{
Initialize();
string groupName = Recording.GenerateAssetName(ResourceGroupPrefix);
string VnetName = Recording.GenerateAssetName("vnetname");
string SubnetName = Recording.GenerateAssetName("subnetname");
string EndpointName = Recording.GenerateAssetName("endpointxyz");
ResGroup = (await ArmClient.GetDefaultSubscriptionAsync().Result.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, groupName, new ResourceGroupData(Location))).Value;
string configurationStoreName = Recording.GenerateAssetName("testapp-");
ConfigurationStoreData configurationStoreData = new ConfigurationStoreData(Location, new AppConfigurationSku("Standard"))
{
PublicNetworkAccess = PublicNetworkAccess.Disabled
};
ConfigStore = (await ResGroup.GetConfigurationStores().CreateOrUpdateAsync(WaitUntil.Completed, configurationStoreName, configurationStoreData)).Value;
// Prepare VNet and Private Endpoint
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = "eastus",
Subnets = { new SubnetData()
{
Name = SubnetName, AddressPrefix = "10.0.0.0/24", PrivateEndpointNetworkPolicies = "Disabled"
} }
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
vnetData.DhcpOptionsDnsServers.Add("10.1.1.1");
vnetData.DhcpOptionsDnsServers.Add("10.1.2.4");
VirtualNetworkResource vnet = (await ResGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, VnetName, vnetData)).Value;
PrivateEndpointData privateEndpointData = new PrivateEndpointData()
{
Location = "eastus",
PrivateLinkServiceConnections = { new PrivateLinkServiceConnection()
{
Name = "myconnection",
PrivateLinkServiceId = ConfigStore.Data.Id,
GroupIds = { "configurationStores" },
RequestMessage = "Please approve my connection",
} },
Subnet = new SubnetData()
{
Id = "/subscriptions/" + TestEnvironment.SubscriptionId + "/resourceGroups/" + groupName + "/providers/Microsoft.Network/virtualNetworks/" + VnetName + "/subnets/" + SubnetName
}
};
PrivateEndpointResource = (await ResGroup.GetPrivateEndpoints().CreateOrUpdateAsync(WaitUntil.Completed, EndpointName, privateEndpointData)).Value;
}
}
protected async Task <PrivateEndpointResource> CreatePrivateEndpoint()
{
var vnetName = Recording.GenerateAssetName("vnet-");
var vnet = new VirtualNetworkData()
{
Location = AzureLocation.WestUS,
Subnets = { new SubnetData()
{
Name = "default",
AddressPrefix = "10.0.1.0/24",
PrivateEndpointNetworkPolicies = VirtualNetworkPrivateEndpointNetworkPolicies.Disabled
} }
};
vnet.AddressPrefixes.Add("10.0.0.0/16");
vnet.DhcpOptionsDnsServers.Add("10.1.1.1");
vnet.DhcpOptionsDnsServers.Add("10.1.2.4");
VirtualNetworkResource virtualNetwork = (await _resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnet)).Value;
var name = Recording.GenerateAssetName("pe-");
var privateEndpointData = new PrivateEndpointData
{
Location = AzureLocation.WestUS,
Subnet = virtualNetwork.Data.Subnets[0],
ManualPrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/providers/Microsoft.Storage/storageAccounts/{storageAccount.Name}",
PrivateLinkServiceId = _databaseAccountIdentifier,
RequestMessage = "SDK test",
GroupIds = { "MongoDB" }
}
},
};
return((await _resourceGroup.GetPrivateEndpoints().CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value);
}
public async Task CreatePrivateEndpointConnection(string privateEndPointName)
{
//create private endpoint (privateEndpoint of WebPubSUb will be generated automatically)
var privateEndPointData = new PrivateEndpointData()
{
Subnet = new SubnetData()
{
Id = new ResourceIdentifier($"{_vnet.Id}" + "/subnets/subnet02")
},
Location = "westus2",
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection()
{
Name = privateEndPointName,
PrivateLinkServiceId = _webPubSub.Data.Id.ToString(),
GroupIds = { "webpubsub" },
}
},
};
var privateEndPointContainer = _resourceGroup.GetPrivateEndpoints();
var privateEndPointLro = await(await privateEndPointContainer.CreateOrUpdateAsync(WaitUntil.Completed, privateEndPointName, privateEndPointData)).WaitForCompletionAsync();
}
public async Task PrivateEndpointConnectionCreateAndUpdate()
{
/*
* CAUTION: all private endpoint methods do not work properly now, so just temporally use Network's private endpoint methods for testing.
* Will confirm service team that this is expected.
*/
// Create a vault first
VaultResource vaultResource = (await CreateVault()).Value;
// Create a vnet
VirtualNetworkResource vnetResource = (await createVirtualNetwork()).Value;
// Create the private endpoint
PrivateEndpointData privateEndpointData = new PrivateEndpointData
{
Location = Location,
Subnet = vnetResource.Data.Subnets[0],
ManualPrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{SubscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}",
PrivateLinkServiceId = vaultResource.Data.Id.ToString(),
RequestMessage = "SDK test",
GroupIds = { "vault" }
}
},
};
string privateEndpointName = Recording.GenerateAssetName("pe-");
PrivateEndpointCollection privateEndpointCollection = ResourceGroupResource.GetPrivateEndpoints();
PrivateEndpointResource privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateEndpointName, privateEndpointData)).Value;
// get
privateEndpoint = (await privateEndpointCollection.GetAsync(privateEndpointName)).Value;
Assert.AreEqual(privateEndpoint.Data.Name, privateEndpointName);
Assert.AreEqual(privateEndpoint.Data.Location, Location.ToString());
Assert.IsEmpty(privateEndpoint.Data.Tags);
// update
privateEndpointData.Tags.Add("test", "test");
privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateEndpoint.Data.Name, privateEndpointData)).Value;
Assert.AreEqual(privateEndpoint.Data.Name, privateEndpointName);
Assert.AreEqual(privateEndpoint.Data.Location, Location.ToString());
Assert.That(privateEndpoint.Data.Tags, Has.Count.EqualTo(1));
Assert.That(privateEndpoint.Data.Tags, Does.ContainKey("test").WithValue("test"));
// list
List <PrivateEndpointResource> privateEndpoints = (await privateEndpointCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.Count.EqualTo(1));
Assert.AreEqual(privateEndpointName, privateEndpoint.Data.Name);
// delete
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
// list all
privateEndpoints = (await Subscription.GetPrivateEndpointsAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.None.Matches <PrivateEndpointResource>(p => p.Data.Name == privateEndpointName));
}
public async Task PrivateDnsZoneGroupTest()
{
virtualNetwork = (await createVirtualNetwork()).Value;
storageAccount = await createStorageAccount();
// create
var privateEndpointCollection = resourceGroup.GetPrivateEndpoints();
var name = Recording.GenerateAssetName("pe");
System.Console.WriteLine($"Subnet ID: {virtualNetwork.Data.Subnets[0].Id}");
var privateEndpointData = new PrivateEndpointData
{
Location = TestEnvironment.Location,
Subnet = virtualNetwork.Data.Subnets[0],
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = "/subscriptions/db1ab6f0-4769-4b27-930e-01e2ef9c123c/resourceGroups/sdktest7669/providers/Microsoft.KeyVault/vaults/TierRuanKeyVaultJustTest",
PrivateLinkServiceId = storageAccount.Id,
RequestMessage = "SDK test",
GroupIds = { "storage" }
}
},
};
var privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
var privateDnsZoneName = Recording.GenerateAssetName("private_dns_zone");
var privateDnsZoneResourceId = new ResourceIdentifier($"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/Microsoft.Network/privateDnsZones/{privateDnsZoneName}");
privateDnsZone = ArmClient.GetGenericResources().CreateOrUpdate(WaitUntil.Completed, privateDnsZoneResourceId, new GenericResourceData(TestEnvironment.Location)).Value;
var privateDnsZoneGroupName = Recording.GenerateAssetName("private_dns_zone_group");
var privateDnsZoneGroupCollection = privateEndpoint.GetPrivateDnsZoneGroups();
var privateDnsZoneGroup = (await privateDnsZoneGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateDnsZoneGroupName, new PrivateDnsZoneGroupData {
PrivateDnsZoneConfigs =
{
new PrivateDnsZoneConfig
{
Name = privateDnsZoneName,
PrivateDnsZoneId = privateDnsZone.Id,
}
}
})).Value;
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// list
var groups = (await privateDnsZoneGroupCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(groups, Has.Count.EqualTo(1));
privateDnsZoneGroup = groups[0];
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// get
privateDnsZoneGroup = (await privateDnsZoneGroupCollection.GetAsync(privateDnsZoneGroupName)).Value;
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// update
privateDnsZoneGroup = (await privateDnsZoneGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateDnsZoneGroupName, new PrivateDnsZoneGroupData {
})).Value;
Assert.IsEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
// delete
await privateDnsZoneGroup.DeleteAsync(WaitUntil.Completed);
// list again
groups = (await privateDnsZoneGroupCollection.GetAllAsync().ToEnumerableAsync());
Assert.IsEmpty(groups);
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
}
public async Task PrivateEndpointTest()
{
virtualNetwork = (await createVirtualNetwork()).Value;
storageAccount = await createStorageAccount();
// create
var privateEndpointCollection = resourceGroup.GetPrivateEndpoints();
var name = Recording.GenerateAssetName("pe");
System.Console.WriteLine($"Subnet ID: {virtualNetwork.Data.Subnets[0].Id}");
var privateEndpointData = new PrivateEndpointData
{
Location = TestEnvironment.Location,
Subnet = virtualNetwork.Data.Subnets[0],
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/providers/Microsoft.Storage/storageAccounts/{storageAccount.Name}",
PrivateLinkServiceId = storageAccount.Id,
RequestMessage = "SDK test",
GroupIds = { "storage" }
}
},
};
var privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.IsEmpty(privateEndpoint.Data.Tags);
// get
privateEndpoint = (await privateEndpointCollection.GetAsync(name)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.IsEmpty(privateEndpoint.Data.Tags);
// update
privateEndpointData.Tags.Add("test", "test");
privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.That(privateEndpoint.Data.Tags, Has.Count.EqualTo(1));
Assert.That(privateEndpoint.Data.Tags, Does.ContainKey("test").WithValue("test"));
// list
var privateEndpoints = (await privateEndpointCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.Count.EqualTo(1));
Assert.AreEqual(name, privateEndpoint.Data.Name);
// delete
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
// list all
privateEndpoints = (await _subscription.GetPrivateEndpointsAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.None.Matches <PrivateEndpoint>(p => p.Data.Name == name));
}
internal static PrivateEndpointConnection DeserializePrivateEndpointConnection(JsonElement element)
{
Optional <string> name = default;
Optional <string> type = default;
Optional <string> etag = default;
Optional <string> id = default;
Optional <PrivateEndpointData> privateEndpoint = default;
Optional <PrivateLinkServiceConnectionState> privateLinkServiceConnectionState = default;
Optional <ProvisioningState> provisioningState = default;
Optional <string> linkIdentifier = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("type"))
{
type = property.Value.GetString();
continue;
}
if (property.NameEquals("etag"))
{
etag = property.Value.GetString();
continue;
}
if (property.NameEquals("id"))
{
id = property.Value.GetString();
continue;
}
if (property.NameEquals("properties"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
foreach (var property0 in property.Value.EnumerateObject())
{
if (property0.NameEquals("privateEndpoint"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
privateEndpoint = PrivateEndpointData.DeserializePrivateEndpointData(property0.Value);
continue;
}
if (property0.NameEquals("privateLinkServiceConnectionState"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
privateLinkServiceConnectionState = PrivateLinkServiceConnectionState.DeserializePrivateLinkServiceConnectionState(property0.Value);
continue;
}
if (property0.NameEquals("provisioningState"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
provisioningState = new ProvisioningState(property0.Value.GetString());
continue;
}
if (property0.NameEquals("linkIdentifier"))
{
linkIdentifier = property0.Value.GetString();
continue;
}
}
continue;
}
}
return(new PrivateEndpointConnection(id.Value, name.Value, type.Value, etag.Value, privateEndpoint.Value, privateLinkServiceConnectionState.Value, Optional.ToNullable(provisioningState), linkIdentifier.Value));
}
