public ManagedPrivateEndpoint CreateManagedPrivateEndpoint(string managedPrivateEndpointName, string rawJsonContent, string managedVirtualNetworkName = "default")
{
ManagedPrivateEndpoint managedPrivateEndpoint = JsonConvert.DeserializeObject <ManagedPrivateEndpoint>(rawJsonContent);
var operation = _managedPrivateEndpointClient.Create(managedPrivateEndpointName, managedPrivateEndpoint, managedVirtualNetworkName);
return(operation.Value);
}
public void TestManagedPrivateEndpoint()
{
#region Snippet:CreateManagedPrivateEndpoint
string managedVnetName = "default";
string managedPrivateEndpointName = "myPrivateEndpoint";
string fakedStorageAccountName = "myStorageAccount";
string privateLinkResourceId = $"/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/myResourceGroup/providers/Microsoft.Storage/accounts/{fakedStorageAccountName}";
string groupId = "blob";
client.Create(managedVnetName, managedPrivateEndpointName, new ManagedPrivateEndpoint
{
Properties = new ManagedPrivateEndpointProperties
{
PrivateLinkResourceId = privateLinkResourceId,
GroupId = groupId
}
});
#endregion
#region Snippet:ListManagedPrivateEndpoints
List <ManagedPrivateEndpoint> privateEndpoints = client.List(managedVnetName).ToList();
foreach (ManagedPrivateEndpoint privateEndpoint in privateEndpoints)
{
Console.WriteLine(privateEndpoint.Id);
}
#endregion
#region Snippet:RetrieveManagedPrivateEndpoint
ManagedPrivateEndpoint retrievedPrivateEndpoint = client.Get(managedVnetName, managedPrivateEndpointName);
Console.WriteLine(retrievedPrivateEndpoint.Id);
#endregion
#region Snippet:DeleteManagedPrivateEndpoint
client.Delete(managedVnetName, managedPrivateEndpointName);
#endregion
}
public PSManagedPrivateEndpointResource(ManagedPrivateEndpoint managedPrivateEndpoint, string workspaceName)
{
this.WorkspaceName = workspaceName;
this.Id = managedPrivateEndpoint?.Id;
this.Name = managedPrivateEndpoint?.Name;
this.Type = managedPrivateEndpoint?.Type;
this.Properties = managedPrivateEndpoint?.Properties != null? new PSManagedPrivateEndpointProperties(managedPrivateEndpoint.Properties) : null;
}
public void TestManagedPrivateEndpoint()
{
#region Snippet:CreateManagedPrivateClient
#if SNIPPET
// Replace the string below with your actual endpoint url.
string endpoint = "<my-endpoint-url>";
#else
string endpoint = TestEnvironment.EndpointUrl;
#endif
ManagedPrivateEndpointsClient client = new ManagedPrivateEndpointsClient(endpoint: new Uri(endpoint), credential: new DefaultAzureCredential(includeInteractiveCredentials: true));
#endregion
#region Snippet:CreateManagedPrivateEndpoint
string managedVnetName = "default";
string managedPrivateEndpointName = "myPrivateEndpoint";
string fakedStorageAccountName = "myStorageAccount";
string privateLinkResourceId = $"/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/myResourceGroup/providers/Microsoft.Storage/accounts/{fakedStorageAccountName}";
string groupId = "blob";
client.Create(managedVnetName, new ManagedPrivateEndpoint
{
Properties = new ManagedPrivateEndpointProperties
{
PrivateLinkResourceId = privateLinkResourceId,
GroupId = groupId
}
});
#endregion
#region Snippet:ListManagedPrivateEndpoints
List <ManagedPrivateEndpoint> privateEndpoints = client.List(managedVnetName).ToList();
foreach (ManagedPrivateEndpoint privateEndpoint in privateEndpoints)
{
Console.WriteLine(privateEndpoint.Id);
}
#endregion
#region Snippet:RetrieveManagedPrivateEndpoint
ManagedPrivateEndpoint retrievedPrivateEndpoint = client.Get(managedVnetName, managedPrivateEndpointName);
Console.WriteLine(retrievedPrivateEndpoint.Id);
#endregion
#region Snippet:DeleteManagedPrivateEndpoint
client.Delete(managedVnetName, managedPrivateEndpointName);
#endregion
}
public async Task TestManagedPrivateEndpoints()
{
ManagedPrivateEndpointsClient client = CreateClient();
// Create a managed private endpoint
string managedVnetName = "default";
string managedPrivateEndpointName = Recording.GenerateId("myPrivateEndpoint", 21);
string fakedStorageAccountName = Recording.GenerateId("myStorageAccount", 21);
string privateLinkResourceId = $"/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/myResourceGroup/providers/Microsoft.Storage/accounts/{fakedStorageAccountName}";
string groupId = "blob";
ManagedPrivateEndpoint managedPrivateEndpoint = await client.CreateAsync(managedVnetName, new ManagedPrivateEndpoint
{
Properties = new ManagedPrivateEndpointProperties
{
PrivateLinkResourceId = privateLinkResourceId,
GroupId = groupId
}
});
Assert.NotNull(managedPrivateEndpoint);
Assert.AreEqual(managedPrivateEndpointName, managedPrivateEndpoint.Name);
Assert.AreEqual(privateLinkResourceId, managedPrivateEndpoint.Properties.PrivateLinkResourceId);
Assert.AreEqual(groupId, managedPrivateEndpoint.Properties.GroupId);
// List managed private endpoints
List <ManagedPrivateEndpoint> privateEndpoints = await client.ListAsync(managedVnetName).ToEnumerableAsync();
Assert.NotNull(privateEndpoints);
CollectionAssert.IsNotEmpty(privateEndpoints);
Assert.IsTrue(privateEndpoints.Any(pe => pe.Name == managedPrivateEndpointName));
// Get managed private endpoint
ManagedPrivateEndpoint privateEndpoint = await client.GetAsync(managedVnetName, managedPrivateEndpointName);
Assert.AreEqual(managedPrivateEndpointName, privateEndpoint.Name);
// Delete managed private endpoint
await client.DeleteAsync(managedVnetName, managedPrivateEndpointName);
privateEndpoints = await client.ListAsync(managedVnetName).ToEnumerableAsync();
Assert.IsFalse(privateEndpoints.Any(pe => pe.Name == managedPrivateEndpointName));
}
public async Task <Response <ManagedPrivateEndpoint> > GetAsync(string managedPrivateEndpointName, string managedVirtualNetworkName = "default", CancellationToken cancellationToken = default)
{
if (managedPrivateEndpointName == null)
{
throw new ArgumentNullException(nameof(managedPrivateEndpointName));
}
if (managedVirtualNetworkName == null)
{
throw new ArgumentNullException(nameof(managedVirtualNetworkName));
}
using var message = CreateGetRequest(managedPrivateEndpointName, managedVirtualNetworkName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
ManagedPrivateEndpoint value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = ManagedPrivateEndpoint.DeserializeManagedPrivateEndpoint(document.RootElement);
return(Response.FromValue(value, message.Response));
}
/// <summary>
/// Updates a managed private endpoint.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group containing the Kusto cluster.
/// </param>
/// <param name='clusterName'>
/// The name of the Kusto cluster.
/// </param>
/// <param name='managedPrivateEndpointName'>
/// The name of the managed private endpoint.
/// </param>
/// <param name='parameters'>
/// The managed private endpoint parameters.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ManagedPrivateEndpoint> BeginUpdateAsync(this IManagedPrivateEndpointsOperations operations, string resourceGroupName, string clusterName, string managedPrivateEndpointName, ManagedPrivateEndpoint parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, clusterName, managedPrivateEndpointName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Updates a managed private endpoint.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group containing the Kusto cluster.
/// </param>
/// <param name='clusterName'>
/// The name of the Kusto cluster.
/// </param>
/// <param name='managedPrivateEndpointName'>
/// The name of the managed private endpoint.
/// </param>
/// <param name='parameters'>
/// The managed private endpoint parameters.
/// </param>
public static ManagedPrivateEndpoint BeginUpdate(this IManagedPrivateEndpointsOperations operations, string resourceGroupName, string clusterName, string managedPrivateEndpointName, ManagedPrivateEndpoint parameters)
{
return(operations.BeginUpdateAsync(resourceGroupName, clusterName, managedPrivateEndpointName, parameters).GetAwaiter().GetResult());
}
public virtual Response <ManagedPrivateEndpoint> Create(string managedPrivateEndpointName, ManagedPrivateEndpoint managedPrivateEndpoint, string managedVirtualNetworkName = "default", CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ManagedPrivateEndpointsClient.Create");
scope.Start();
try
{
return(RestClient.Create(managedPrivateEndpointName, managedPrivateEndpoint, managedVirtualNetworkName, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <ManagedPrivateEndpoint> > CreateAsync(string managedVirtualNetworkName, string managedPrivateEndpointName, ManagedPrivateEndpoint managedPrivateEndpoint, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ManagedPrivateEndpointsClient.Create");
scope.Start();
try
{
return(await RestClient.CreateAsync(managedVirtualNetworkName, managedPrivateEndpointName, managedPrivateEndpoint, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
