public async Task SslStream_StreamToStream_Successive_ClientWrite_Success()
{
byte[] recvBuf = new byte[_sampleMsg.Length];
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var clientSslStream = new SslStream(clientStream, false, AllowAnyServerCertificate))
using (var serverSslStream = new SslStream(serverStream))
{
await DoHandshake(clientSslStream, serverSslStream);
await WriteAsync(clientSslStream, _sampleMsg, 0, _sampleMsg.Length)
.TimeoutAfter(TestConfiguration.PassingTestTimeoutMilliseconds);
int bytesRead = 0;
while (bytesRead < _sampleMsg.Length)
{
bytesRead += await ReadAsync(serverSslStream, recvBuf, bytesRead, _sampleMsg.Length - bytesRead)
.TimeoutAfter(TestConfiguration.PassingTestTimeoutMilliseconds);
}
Assert.True(VerifyOutput(recvBuf, _sampleMsg), "verify first read data is as expected.");
await WriteAsync(clientSslStream, _sampleMsg, 0, _sampleMsg.Length)
.TimeoutAfter(TestConfiguration.PassingTestTimeoutMilliseconds);
bytesRead = 0;
while (bytesRead < _sampleMsg.Length)
{
bytesRead += await ReadAsync(serverSslStream, recvBuf, bytesRead, _sampleMsg.Length - bytesRead)
.TimeoutAfter(TestConfiguration.PassingTestTimeoutMilliseconds);
}
Assert.True(VerifyOutput(recvBuf, _sampleMsg), "verify second read data is as expected.");
}
}
private (List <string> Log, bool Succeeded, Exception Error) Inspect(string where)
{
var command = $"lighthouse inspect --where {where}";
var virtualNetwork = new VirtualNetwork();
var typeFactory = new TypeFactory();
typeFactory.Register <INetworkProvider>(() => virtualNetwork);
var pingContainer = Substitute.For <ILighthouseServiceContainer>();
virtualNetwork.Register(pingContainer);
RemoteAppRunRequest receivedRequest = null;
var returnValue = new RemoteAppRunHandle(Guid.NewGuid().ToString());
pingContainer.HandleRequest <RemoteAppRunRequest, RemoteAppRunHandle>(Arg.Do <RemoteAppRunRequest>(r => receivedRequest = r)).Returns(returnValue);
var consoleWrites = new List <string>();
var runner = new CommandLineRunner((log) => {
consoleWrites.Add(log);
Output.WriteLine(log);
}, () => "no_console_reads", typeFactory);
try
{
var returnCode = runner.Run(command.Split(" ").Skip(1));
receivedRequest.Should().NotBeNull();
return(consoleWrites, true, null);
}
catch (Exception e)
{
return(consoleWrites, false, e);
}
}
public async Task NegotiateStream_StreamToStream_Successive_ClientWrite_Sync_Success()
{
byte[] recvBuf = new byte[s_sampleMsg.Length];
VirtualNetwork network = new VirtualNetwork();
int bytesRead = 0;
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated);
Assert.False(server.IsAuthenticated);
Task[] auth = new Task[2];
auth[0] = AuthenticateAsClientAsync(client, CredentialCache.DefaultNetworkCredentials, string.Empty);
auth[1] = AuthenticateAsServerAsync(server);
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(auth);
client.Write(s_sampleMsg, 0, s_sampleMsg.Length);
server.Read(recvBuf, 0, s_sampleMsg.Length);
Assert.True(s_sampleMsg.SequenceEqual(recvBuf));
client.Write(s_sampleMsg, 0, s_sampleMsg.Length);
// Test partial sync read.
bytesRead = server.Read(recvBuf, 0, PartialBytesToRead);
Assert.Equal(PartialBytesToRead, bytesRead);
bytesRead = server.Read(recvBuf, PartialBytesToRead, s_sampleMsg.Length - PartialBytesToRead);
Assert.Equal(s_sampleMsg.Length - PartialBytesToRead, bytesRead);
Assert.True(s_sampleMsg.SequenceEqual(recvBuf));
}
}
public async Task NegotiateStream_EndReadEndWriteInvalidParameter_Throws()
{
byte[] recvBuf = new byte[s_sampleMsg.Length];
var network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
client.AuthenticateAsClientAsync(CredentialCache.DefaultNetworkCredentials, string.Empty),
server.AuthenticateAsServerAsync());
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
Task.Factory.FromAsync(client.BeginWrite,
(asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndWrite(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndWrite(result));
},
s_sampleMsg, 0, s_sampleMsg.Length, client),
Task.Factory.FromAsync(server.BeginRead,
(asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndRead(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndRead(result));
},
recvBuf, 0, s_sampleMsg.Length, server));
}
}
public async Task NewCode()
{
#endif
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroup resourceGroup = await subscription.GetResourceGroups().GetAsync("abc");
VirtualNetworkCollection virtualNetworkContainer = resourceGroup.GetVirtualNetworks();
// Create VNet
VirtualNetworkData vnet = new VirtualNetworkData()
{
Location = "westus",
};
vnet.AddressSpace.AddressPrefixes.Add("10.0.0.0/16");
vnet.Subnets.Add(new SubnetData
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
});
ArmOperation<VirtualNetwork> vnetOperation = await virtualNetworkContainer.CreateOrUpdateAsync(true, "_vent", vnet);
VirtualNetwork virtualNetwork = vnetOperation.Value;
#endregion
}
public void NegotiateStream_StreamToStream_KerberosAuthInvalidUser_Failure()
{
if (!_isKrbAvailable)
{
_output.WriteLine("skipping NegotiateStream_StreamToStream_KerberosAuthInvalidUser_Failure");
return;
}
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new UnixGssFakeNegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated, "client is not authenticated by default");
string user = string.Format("{0}@{1}", TestConfiguration.KerberosUser, TestConfiguration.Realm);
string target = string.Format("{0}@{1}", TestConfiguration.HostTarget, TestConfiguration.Realm);
NetworkCredential credential = new NetworkCredential(user.Substring(1), _fixture.password);
Assert.ThrowsAsync <AuthenticationException>(() => client.AuthenticateAsClientAsync(credential, target));
Assert.ThrowsAsync <AuthenticationException>(() => server.AuthenticateAsServerAsync());
}
}
public async Task StreamToStream_ValidAuthentication_Success(NetworkCredential creds, string target)
{
var network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated);
Assert.False(server.IsAuthenticated);
Task[] auth = new Task[2];
auth[0] = client.AuthenticateAsClientAsync(creds, target);
auth[1] = server.AuthenticateAsServerAsync();
await WhenAllOrAnyFailedWithTimeout(auth);
VerifyStreamProperties(client, isServer: false, target);
string remoteName = creds.UserName + "@" + EnterpriseTestConfiguration.Realm;
VerifyStreamProperties(server, isServer: true, remoteName);
}
}
public async Task Read_InvokedSynchronously()
{
var network = new VirtualNetwork();
var clientStream = new PreReadWriteActionDelegatingStream(new VirtualNetworkStream(network, isServer: false));
using (var clientSslStream = new SslStream(clientStream, false, AllowAnyServerCertificate))
using (var serverSslStream = new SslStream(new VirtualNetworkStream(network, isServer: true)))
{
await DoHandshake(clientSslStream, serverSslStream);
// Validate that the read call to the underlying stream is made as part of the
// synchronous call to the read method on SslStream, even if the method is async.
using (var tl = new ThreadLocal <int>())
{
await WriteAsync(serverSslStream, new byte[1], 0, 1);
tl.Value = 42;
clientStream.PreReadWriteAction = () => Assert.Equal(42, tl.Value);
Task t = ReadAsync(clientSslStream, new byte[1], 0, 1);
tl.Value = 0;
await t;
}
}
}
public async Task GlobalSetUp()
{
var rgLro = await GlobalClient.GetDefaultSubscriptionAsync().Result.GetResourceGroups().CreateOrUpdateAsync(true, SessionRecording.GenerateAssetName("WebPubSubRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroup rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
_vnetName = SessionRecording.GenerateAssetName("Vnet-");
_privateEndPointName = SessionRecording.GenerateAssetName("PrivateEndPoint-");
//create vnet
var vnetData = new VirtualNetworkData()
{
Location = "westus2",
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.10.0.0/16", }
},
Subnets =
{
new SubnetData()
{
Name = "subnet01", AddressPrefix = "10.10.1.0/24",
},
new SubnetData()
{
Name = "subnet02", AddressPrefix = "10.10.2.0/24", PrivateEndpointNetworkPolicies = "Disabled",
}
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(true, _vnetName, vnetData);
_vnet = vnetLro.Value;
await StopSessionRecordingAsync();
}
public static VirtualNetwork CreateVirtualNetwork(string vnetName, string subnetName, string resourceGroupName, string location, NetworkManagementClient client)
{
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/16",
}
},
DhcpOptions = new DhcpOptions()
{
DnsServers = new List <string>()
{
"10.1.1.1",
"10.1.2.4"
}
},
Subnets = new List <Subnet>()
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24",
}
}
};
client.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);
var getVnetResponse = client.VirtualNetworks.Get(resourceGroupName, vnetName);
return(getVnetResponse);
}
private string CreateDefaultVNetWithSubnet(string virtualNetworkName, string subnetName, ApiManagementTestBase testBase)
{
var vnet = new VirtualNetwork()
{
Location = testBase.location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/16",
}
},
Subnets = new List <Subnet>()
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.1.0/24",
PrivateEndpointNetworkPolicies = "Disabled"
},
}
};
// Put Vnet
var putVnetResponse = testBase.networkClient.VirtualNetworks.CreateOrUpdate(testBase.rgName, virtualNetworkName, vnet);
Assert.Equal("Succeeded", putVnetResponse.ProvisioningState);
var getSubnetResponse = testBase.networkClient.Subnets.Get(testBase.rgName, virtualNetworkName, subnetName);
Assert.NotNull(getSubnetResponse);
Assert.NotNull(getSubnetResponse.Id);
return(getSubnetResponse.Id);
}
protected VirtualNetwork CreateVirtualNetwork(string resourceGroupName, string vnetName, string subnetName)
{
try
{
// Create the resource Group.
var resourceGroup = m_ResourcesClient.ResourceGroups.CreateOrUpdate(
resourceGroupName,
new ResourceGroup
{
Location = m_location,
Tags = new Dictionary <string, string>()
{
{ resourceGroupName, DateTime.UtcNow.ToString("u") }
}
});
VirtualNetwork vnetParams = GenerateVnetModel(vnetName, subnetName);
return(m_NrpClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnetParams));
}
catch
{
m_ResourcesClient.ResourceGroups.Delete(resourceGroupName);
throw;
}
}
public MyStack()
{
_Subnets = new Dictionary <string, Subnet>();
_foodVmNics = new List <NetworkInterface>();
// Create an Azure Resource Group
_ResourceGroup = new ResourceGroup("rsgMarketPlace", new ResourceGroupArgs
{
Location = Location,
Name = "rsgMarketPlace"
}, new CustomResourceOptions
{
Protect = true
});
_vnet = BuildVNet();
_stgPrimaryEndpoint = BuildBootDiagStorageAccount();
BuildNSG();
BuildSupplierVMs(3);
BuildFoodVMs(2);
BuildClothingVMs(1);
BuildFarmingVMs(1);
BuildGardenVMs(1);
BuildFoodLoadBalancer();
//BuildFirewall();
//BuildRouteTable();
//BuildAppGateway();
//new CosmosDB(_ResourceGroup).BuildCosmosDb();
new SecondRegion(_vnet);
}
public async Task GlobalSetUp()
{
Subscription subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(SessionRecording.GenerateAssetName("FirewallRG-"), new ResourceGroupData(Location.WestUS2));
ResourceGroup rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = Location.WestUS2,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.20.0.0/16", }
},
Subnets = {
new SubnetData() { Name = "Default", AddressPrefix = "10.20.1.0/26", },
new SubnetData() { Name = "AzureFirewallSubnet", AddressPrefix = "10.20.2.0/26", },
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(SessionRecording.GenerateAssetName("vnet-"), vnetData);
_network = vnetLro.Value;
_networkIdentifier = _network.Id;
PublicIPAddressData ipData = new PublicIPAddressData()
{
Location = Location.WestUS2,
PublicIPAllocationMethod = IPAllocationMethod.Static,
Sku = new PublicIPAddressSku() { Name = PublicIPAddressSkuName.Standard },
};
var ipLro = await rg.GetPublicIPAddresses().CreateOrUpdateAsync(SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
_firewallName = SessionRecording.GenerateAssetName("firewall-");
await StopSessionRecordingAsync();
}
public async Task <Response <VirtualNetwork> > GetAsync(string resourceGroupName, string virtualNetworkName, string expand = null, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (virtualNetworkName == null)
{
throw new ArgumentNullException(nameof(virtualNetworkName));
}
using var message = CreateGetRequest(resourceGroupName, virtualNetworkName, expand);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
VirtualNetwork value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = VirtualNetwork.DeserializeVirtualNetwork(document.RootElement);
return(Response.FromValue(value, message.Response));
}
public async Task VirtualNetworkPeeringTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
string vnet1Name = Recording.GenerateAssetName("azsmnet");
string vnet2Name = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
var vnet = new VirtualNetworkData()
{
Location = location,
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 = subnet1Name, AddressPrefix = "10.0.1.0/24",
}, new SubnetData()
{
Name = subnet2Name, AddressPrefix = "10.0.2.0/24"
} }
};
// Put Vnet
var virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
var putVnetResponseOperation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnet1Name, vnet);
Response <VirtualNetwork> putVnetResponse = await putVnetResponseOperation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnetResponse.Value.Data.ProvisioningState.ToString());
// Get Vnet
Response <VirtualNetwork> getVnetResponse = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, getVnetResponse.Value.Data.Name);
Assert.NotNull(getVnetResponse.Value.Data.ResourceGuid);
Assert.AreEqual("Succeeded", getVnetResponse.Value.Data.ProvisioningState.ToString());
// Create vnet2
var vnet2 = new VirtualNetworkData()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.1.0.0/16", }
},
Subnets = { new SubnetData()
{
Name = subnet1Name, AddressPrefix = "10.1.1.0/24"
} }
};
// Put Vnet2
var putVnet2Operation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnet2Name, vnet2);
Response <VirtualNetwork> putVnet2 = await putVnet2Operation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnet2.Value.Data.ProvisioningState.ToString());
// Create peering object
var peering = new VirtualNetworkPeeringData()
{
AllowForwardedTraffic = true,
RemoteVirtualNetwork = new WritableSubResource {
Id = putVnet2.Value.Id
}
};
// Create Peering
var virtualNetworkPeeringCollection = getVnetResponse.Value.GetVirtualNetworkPeerings();
await virtualNetworkPeeringCollection.CreateOrUpdateAsync(true, "peer1", peering);
// Get Peering
VirtualNetworkPeering getPeer = await virtualNetworkPeeringCollection.GetAsync("peer1");
Assert.AreEqual("peer1", getPeer.Data.Name);
Assert.True(getPeer.Data.AllowForwardedTraffic);
Assert.True(getPeer.Data.AllowVirtualNetworkAccess);
Assert.False(getPeer.Data.AllowGatewayTransit);
Assert.NotNull(getPeer.Data.RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, getPeer.Data.RemoteVirtualNetwork.Id);
// List Peering
AsyncPageable <VirtualNetworkPeering> listPeerAP = virtualNetworkPeeringCollection.GetAllAsync();
List <VirtualNetworkPeering> listPeer = await listPeerAP.ToEnumerableAsync();
Has.One.EqualTo(listPeer);
Assert.AreEqual("peer1", listPeer[0].Data.Name);
Assert.True(listPeer[0].Data.AllowForwardedTraffic);
Assert.True(listPeer[0].Data.AllowVirtualNetworkAccess);
Assert.False(listPeer[0].Data.AllowGatewayTransit);
Assert.NotNull(listPeer[0].Data.RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, listPeer[0].Data.RemoteVirtualNetwork.Id);
// Get peering from GET vnet
VirtualNetwork peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Data.Name);
Has.One.EqualTo(peeringVnet.Data.VirtualNetworkPeerings);
Assert.AreEqual("peer1", peeringVnet.Data.VirtualNetworkPeerings[0].Name);
Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowForwardedTraffic);
Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess);
Assert.False(peeringVnet.Data.VirtualNetworkPeerings[0].AllowGatewayTransit);
Assert.NotNull(peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id);
// Delete Peering
var deleteOperation = await getPeer.DeleteAsync(true);
await deleteOperation.WaitForCompletionResponseAsync();;
listPeerAP = virtualNetworkPeeringCollection.GetAllAsync();
listPeer = await listPeerAP.ToEnumerableAsync();
Assert.IsEmpty(listPeer);
peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Data.Name);
Assert.IsEmpty(peeringVnet.Data.VirtualNetworkPeerings);
// Delete Vnets
await putVnet2.Value.DeleteAsync(true);
await putVnetResponse.Value.DeleteAsync(true);
}
public async Task CreateOrUpdate()
{
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
string vnetName = "myVnet";
// Use the same location as the resource group
VirtualNetworkData vnetInput = new VirtualNetworkData()
{
Location = resourceGroup.Data.Location,
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 = "mySubnet", AddressPrefix = "10.0.1.0/24"
} }
};
VirtualNetwork virtualNetwork = await virtualNetworkCollection.CreateOrUpdate(vnetName, vnetInput).WaitForCompletionAsync();
#region Snippet:Managing_Networks_CreateANetworkInterface
PublicIPAddressCollection publicIPAddressCollection = resourceGroup.GetPublicIPAddresses();
string publicIPAddressName = "myIPAddress";
PublicIPAddressData publicIPInput = new PublicIPAddressData()
{
Location = resourceGroup.Data.Location,
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = "myDomain"
}
};
PublicIPAddress publicIPAddress = await publicIPAddressCollection.CreateOrUpdate(publicIPAddressName, publicIPInput).WaitForCompletionAsync();
NetworkInterfaceCollection networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
string networkInterfaceName = "myNetworkInterface";
NetworkInterfaceData networkInterfaceInput = new NetworkInterfaceData()
{
Location = resourceGroup.Data.Location,
IpConfigurations =
{
new NetworkInterfaceIPConfiguration()
{
Name = "ipConfig",
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new PublicIPAddressData()
{
Id = publicIPAddress.Id
},
Subnet = new SubnetData()
{
// use the virtual network just created
Id = virtualNetwork.Data.Subnets[0].Id
}
}
}
};
NetworkInterface networkInterface = await networkInterfaceCollection.CreateOrUpdate(networkInterfaceName, networkInterfaceInput).WaitForCompletionAsync();
#endregion
}
public void DiskPoolCrud()
{
using var context = MockContext.Start(this.GetType());
string resourceGroupName = TestUtilities.GenerateName("sdk-dcrud-rg");
string diskPoolName = TestUtilities.GenerateName("sdk-diskpool");
string diskName = TestUtilities.GenerateName("sdk-test-disk");
string location = "eastus";
CreateResourceGroup(context, location, resourceGroupName);
try
{
using var testBase = new StoragePoolTestBase(context);
var client = testBase.StoragePoolClient;
var vnetName = "sdk-vnet";
var subnetName = "sdk-subnet";
var diskName1 = "sdk-disk";
var diskName2 = "sdk-disk-2";
var availabilityZone = "2";
// create vnet and subnet
var networkClient = context.GetServiceClient <NetworkManagementClient>();
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new[] { "10.0.0.0/16" }
},
Subnets = new[]
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24",
Delegations = new Delegation[1]
{
new Delegation()
{
Name = "diskpool-delegation",
ServiceName = "Microsoft.StoragePool/diskPools",
},
},
},
},
};
networkClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);
var subnet = networkClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
var computeClient = context.GetServiceClient <ComputeManagementClient>();
// create disk 1
var sku = new DiskSku();
sku.Name = DiskStorageAccountTypes.PremiumLRS;
var disk1 = new ManagedDisk()
{
Location = location,
Sku = sku,
Zones = new[] { availabilityZone },
DiskSizeGB = 256,
CreationData = new CreationData(DiskCreateOption.Empty),
MaxShares = 2,
};
computeClient.Disks.CreateOrUpdate(resourceGroupName, diskName1, disk1);
disk1 = computeClient.Disks.Get(resourceGroupName, diskName1);
// create disk pool
var diskPoolSku = new DiskPoolSku("Standard", "Standard");
var diskPool = new DiskPoolCreate(diskPoolSku, subnet.Id, location, new[] { availabilityZone });
client.DiskPools.CreateOrUpdate(resourceGroupName, diskPoolName, diskPool);
// assert that create succeeded
var createdDiskPool = client.DiskPools.Get(resourceGroupName, diskPoolName);
Assert.NotNull(createdDiskPool);
Assert.Equal("Succeeded", createdDiskPool.ProvisioningState);
// update disk pool -- add disk
diskPool.Disks = new Disk[] { new Disk(disk1.Id) };
client.DiskPools.CreateOrUpdate(resourceGroupName, diskPoolName, diskPool);
// assert that create succeeded
var updatedDiskPool = client.DiskPools.Get(resourceGroupName, diskPoolName);
Assert.NotNull(updatedDiskPool);
Assert.Equal("Succeeded", updatedDiskPool.ProvisioningState);
// delete disk pool
client.DiskPools.Delete(resourceGroupName, diskPoolName);
}
finally
{
DeleteResourceGroup(context, resourceGroupName);
}
}
/// <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);
}
public void NetworkInterfaceEnableIPForwardingTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (var context = UndoContext.Current)
{
context.Start();
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
var networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);
var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/networkInterfaces");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// Create Vnet
// Populate parameter for Put Vnet
string vnetName = TestUtilities.GenerateName();
string subnetName = TestUtilities.GenerateName();
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/16",
}
},
DhcpOptions = new DhcpOptions()
{
DnsServers = new List <string>()
{
"10.1.1.1",
"10.1.2.4"
}
},
Subnets = new List <Subnet>()
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24",
}
}
};
var putVnetResponse = networkResourceProviderClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);
Assert.Equal(HttpStatusCode.OK, putVnetResponse.StatusCode);
var getSubnetResponse = networkResourceProviderClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
// Create Nic
string nicName = TestUtilities.GenerateName();
string ipConfigName = TestUtilities.GenerateName();
var nicParameters = new NetworkInterface()
{
Location = location,
Name = nicName,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
IpConfigurations = new List <NetworkInterfaceIpConfiguration>()
{
new NetworkInterfaceIpConfiguration()
{
Name = ipConfigName,
PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,
Subnet = new ResourceId()
{
Id = getSubnetResponse.Subnet.Id
}
}
},
EnableIPForwarding = false,
};
// Test NIC apis
var putNicResponse = networkResourceProviderClient.NetworkInterfaces.CreateOrUpdate(resourceGroupName, nicName, nicParameters);
Assert.Equal(HttpStatusCode.OK, putNicResponse.StatusCode);
var getNicResponse = networkResourceProviderClient.NetworkInterfaces.Get(resourceGroupName, nicName);
Assert.Equal(getNicResponse.NetworkInterface.Name, nicName);
Assert.Equal(getNicResponse.NetworkInterface.ProvisioningState, Microsoft.Azure.Management.Resources.Models.ProvisioningState.Succeeded);
Assert.Null(getNicResponse.NetworkInterface.VirtualMachine);
Assert.Null(getNicResponse.NetworkInterface.MacAddress);
Assert.Equal(1, getNicResponse.NetworkInterface.IpConfigurations.Count);
Assert.Equal(ipConfigName, getNicResponse.NetworkInterface.IpConfigurations[0].Name);
Assert.False(getNicResponse.NetworkInterface.EnableIPForwarding);
getNicResponse.NetworkInterface.EnableIPForwarding = true;
networkResourceProviderClient.NetworkInterfaces.CreateOrUpdate(resourceGroupName, nicName, getNicResponse.NetworkInterface);
getNicResponse = networkResourceProviderClient.NetworkInterfaces.Get(resourceGroupName, nicName);
Assert.Equal(getNicResponse.NetworkInterface.Name, nicName);
Assert.True(getNicResponse.NetworkInterface.EnableIPForwarding);
// Delete Nic
var deleteNicResponse = networkResourceProviderClient.NetworkInterfaces.Delete(resourceGroupName, nicName);
Assert.Equal(HttpStatusCode.OK, deleteNicResponse.StatusCode);
var getListNicResponse = networkResourceProviderClient.NetworkInterfaces.List(resourceGroupName);
Assert.Equal(0, getListNicResponse.NetworkInterfaces.Count);
// Delete VirtualNetwork
var deleteVnetResponse = networkResourceProviderClient.VirtualNetworks.Delete(resourceGroupName, vnetName);
Assert.Equal(HttpStatusCode.OK, deleteVnetResponse.StatusCode);
}
}
public static VirtualNetwork CreateVirtualNetwork(SqlManagementTestContext context, ResourceGroup resourceGroup, string location)
{
NetworkManagementClient networkClient = context.GetClient <NetworkManagementClient>();
// Create vnet andinitialize subnets
string vnetName = SqlManagementTestUtilities.GenerateName();
// Create network security group
NetworkSecurityGroup networkSecurityGroupParams = new NetworkSecurityGroup()
{
Location = TestEnvironmentUtilities.DefaultLocationId,
SecurityRules = new List <SecurityRule>()
{
new SecurityRule()
{
Direction = "Inbound",
Name = "allow_management_inbound",
DestinationAddressPrefix = "*",
DestinationPortRanges = new List <string>()
{
"1433", "1434", "5022", "9000", "9003", "1438", "1440", "1452", "80", "443"
},
SourceAddressPrefix = "*",
SourcePortRange = "*",
Protocol = "Tcp",
Access = "Allow",
Priority = 100
},
new SecurityRule()
{
Direction = "Inbound",
Name = "allow_misubnet_inbound",
DestinationPortRange = "*",
DestinationAddressPrefix = "*",
SourceAddressPrefix = "10.0.0.0/26",
SourcePortRange = "*",
Protocol = "*",
Access = "Allow",
Priority = 200
},
new SecurityRule()
{
Direction = "Inbound",
Name = "allow_health_probe",
DestinationAddressPrefix = "*",
DestinationPortRange = "*",
SourceAddressPrefix = "AzureLoadBalancer",
SourcePortRange = "*",
Protocol = "*",
Access = "Allow",
Priority = 300
},
new SecurityRule()
{
Direction = "Outbound",
Name = "allow_management_outbound",
DestinationAddressPrefix = "*",
DestinationPortRanges = new List <string>()
{
"80", "443", "12000"
},
Protocol = "*",
SourceAddressPrefix = "*",
SourcePortRange = "*",
Access = "Allow",
Priority = 100
},
new SecurityRule()
{
Direction = "Outbound",
Name = "allow_misubnet_outbound",
DestinationAddressPrefix = "10.0.0.0/26",
DestinationPortRange = "*",
Protocol = "*",
SourceAddressPrefix = "*",
SourcePortRange = "*",
Access = "Allow",
Priority = 200
}
}
};
string networkSecurityGroupName = SqlManagementTestUtilities.GenerateName();
networkClient.NetworkSecurityGroups.CreateOrUpdate(resourceGroup.Name, networkSecurityGroupName, networkSecurityGroupParams);
NetworkSecurityGroup securityGroup = networkClient.NetworkSecurityGroups.Get(resourceGroup.Name, networkSecurityGroupName);
// Create route table
RouteTable routeTableParams = new RouteTable()
{
Location = TestEnvironmentUtilities.DefaultLocationId,
Routes = new List <Route>()
{
new Route()
{
Name = SqlManagementTestUtilities.GenerateName(),
AddressPrefix = "0.0.0.0/0",
NextHopType = "Internet"
},
new Route()
{
Name = SqlManagementTestUtilities.GenerateName(),
AddressPrefix = "10.0.0.0/26",
NextHopType = "VnetLocal"
}
}
};
string routeTableName = SqlManagementTestUtilities.GenerateName();
networkClient.RouteTables.CreateOrUpdate(resourceGroup.Name, routeTableName, routeTableParams);
RouteTable routeTable = networkClient.RouteTables.Get(resourceGroup.Name, routeTableName);
// Create subnet
List <Subnet> subnetList = new List <Subnet>();
Subnet subnet = new Subnet()
{
Name = "MISubnet",
AddressPrefix = "10.0.0.0/26",
NetworkSecurityGroup = securityGroup,
RouteTable = routeTable
};
subnetList.Add(subnet);
// Create vnet
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/22",
}
},
Subnets = subnetList
};
// Put Vnet
var putVnetResponse = networkClient.VirtualNetworks.CreateOrUpdate(resourceGroup.Name, vnetName, vnet);
Assert.Equal("Succeeded", putVnetResponse.ProvisioningState);
// Get Vnets
var getVnetResponse = networkClient.VirtualNetworks.Get(resourceGroup.Name, vnetName);
return(getVnetResponse);
}
public VirtualNetworkService
(
ILogger <VirtualNetworkService> logger,
ICommandLineInterface cli,
IVpnConnectionVerifier vpnConnectionVerifier,
IPlatform platform,
Subject <Object> clientServiceRestarting,
Subject <Object> clientServiceRestarted,
VirtualNetwork network
)
{
if (clientServiceRestarting == null)
{
throw new ArgumentNullException(nameof(clientServiceRestarting));
}
if (clientServiceRestarted == null)
{
throw new ArgumentNullException(nameof(clientServiceRestarted));
}
this._Logger = logger ?? throw new ArgumentNullException(nameof(logger));
this._Cli = cli ?? throw new ArgumentNullException(nameof(cli));
this._VpnConnectionVerifier = vpnConnectionVerifier ?? throw new ArgumentNullException(nameof(vpnConnectionVerifier));
this._Platform = platform ?? throw new ArgumentNullException(nameof(platform));
this.Configuration = network ?? throw new ArgumentNullException(nameof(network));
this._IsDisposed = new Subject <Object>();
var __IsInitialized = new Subject <Object>();
clientServiceRestarting
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.Subscribe(this.OnClientServiceRestarting);
clientServiceRestarted
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.Subscribe(this.OnClientServiceRestarted);
this._Account = new BehaviorSubject <Account>(null);
this._Account
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.DistinctUntilChanged()
.Subscribe(this.OnAccountFoundChanged);
this._Device = new BehaviorSubject <Device>(null);
this._Device
.SkipUntil(__IsInitialized)
.TakeUntil(this._IsDisposed)
.DistinctUntilChanged()
.Subscribe(this.OnDeviceFoundChanged);
// this._Interface = new BehaviorSubject<NetworkInterface>(null);
// this._Interface
//
// .TakeUntil(this._IsDisposed)
// .SkipUntil(__IsInitialized)
// .DistinctUntilChanged()
// .Subscribe(this.OnInterfaceFoundChanged);
this._InterfaceName = new BehaviorSubject <String>(null);
this._InterfaceName
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.DistinctUntilChanged()
.Subscribe(this.OnInterfaceFoundChanged);
this._IPv4AddressAssigned = new BehaviorSubject <Boolean?>(null);
this._IPv4AddressAssigned
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnIPv4AddressAssignedChanged);
this._IPv6AddressAssigned = new BehaviorSubject <Boolean?>(null);
this._IPv6AddressAssigned
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnIPv6AddressAssignedChanged);
this._IPv4RoutesAssigned = new BehaviorSubject <Boolean?>(null);
this._IPv4RoutesAssigned
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnIPv4RoutesAppliedChanged);
this._IPv6RoutesAssigned = new BehaviorSubject <Boolean?>(null);
this._IPv6RoutesAssigned
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnIPv6RoutesAppliedChanged);
this._ConfigurationState = new BehaviorSubject <ConfigurationState?>(null);
this._ConfigurationState
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnConfigurationStateChanged);
this._ConnectionState = new BehaviorSubject <ConnectionState?>(null);
this._ConnectionState
.TakeUntil(this._IsDisposed)
.SkipUntil(__IsInitialized)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnConnectionStateChanged);
this._ReachableState = new BehaviorSubject <ReachableState?>(null);
this._ReachableState
.TakeUntil(this._IsDisposed)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnReachableStateChanged);
this._ConnectionVerificationResult = new BehaviorSubject <ConnectionVerificationResult>(null);
this._ConnectionVerificationResult
.TakeUntil(this._IsDisposed)
.NotNull()
.DistinctUntilChanged()
.Subscribe(this.OnConnectionVerificationResultChanged);
__IsInitialized.OnNext(null);
}
public WorkloadStack()
{
var baseStack = new StackReference("evgenyb/iac-base/lab");
var config = new Config();
var environment = Deployment.Instance.StackName;
// Create an Azure Resource Group
var resourceGroup = new ResourceGroup("rg", new ResourceGroupArgs
{
Name = NamingConvention.GetResourceGroupName(environment),
Tags =
{
{ "owner", Constants.TeamPlatform },
{ "environment", environment }
}
});
var vnet = new VirtualNetwork("vnet", new VirtualNetworkArgs
{
Name = NamingConvention.GetVNetName(environment),
ResourceGroupName = resourceGroup.Name,
AddressSpaces =
{
config.Require("vnet.addressSpaces")
},
Tags =
{
{ "owner", Constants.TeamPlatform },
{ "environment", environment }
}
});
// Create a Subnet for the cluster
var aksSubnet = new Subnet("aks-net", new SubnetArgs
{
Name = "aks-net",
ResourceGroupName = resourceGroup.Name,
VirtualNetworkName = vnet.Name,
AddressPrefixes =
{
config.Require("vnet.subnets.aks.addressPrefixes")
},
});
var agwSubnet = new Subnet("agw-net", new SubnetArgs
{
Name = "agw-net",
ResourceGroupName = resourceGroup.Name,
VirtualNetworkName = vnet.Name,
AddressPrefixes =
{
config.Require("vnet.subnets.agw.addressPrefixes")
},
});
// var agwName = NamingConvention.GetAGWName("api", environment);
// var agwPublicIp = new PublicIp("agw-api-pip", new PublicIpArgs
// {
// Name = NamingConvention.GetPublicIpName("agw-api", environment),
// ResourceGroupName = resourceGroup.Name,
// Sku = "Standard",
// AllocationMethod = "Static",
// DomainNameLabel = agwName
// });
//
// var agwMI = new UserAssignedIdentity("agw-mi", new UserAssignedIdentityArgs
// {
// Name = NamingConvention.GetManagedIdentityName("agw", environment),
// ResourceGroupName = resourceGroup.Name
// });
//
// var apiAgw = new ApplicationGateway("agw-api", new ApplicationGatewayArgs
// {
// Name = agwName,
// ResourceGroupName = resourceGroup.Name,
// Identity = new ApplicationGatewayIdentityArgs
// {
// Type = "UserAssigned",
// IdentityIds = agwMI.Id
// },
// Sku = new ApplicationGatewaySkuArgs
// {
// Name = "WAF_v2",
// Tier = "WAF_v2",
// Capacity = 1
// },
// SslCertificates = new []
// {
// new ApplicationGatewaySslCertificateArgs
// {
// Name = "gateway-listener",
// KeyVaultSecretId = config.Require("keyVaultSecretId")
// }
// },
// FrontendPorts = new []
// {
// new ApplicationGatewayFrontendPortArgs
// {
// Name = "port443",
// Port = 443
// },
// new ApplicationGatewayFrontendPortArgs
// {
// Name = "port80",
// Port = 80
// }
// },
// GatewayIpConfigurations = new []
// {
// new ApplicationGatewayGatewayIpConfigurationArgs
// {
// Name = "appGatewayIpConfig",
// SubnetId = agwSubnet.Id
// }
// },
// FrontendIpConfigurations = new []
// {
// new ApplicationGatewayFrontendIpConfigurationArgs
// {
// Name = "appGatewayFrontendIP",
// PublicIpAddressId = agwPublicIp.Id
// }
// },
// HttpListeners = new []
// {
// new ApplicationGatewayHttpListenerArgs
// {
// Name = "gateway-listener",
// FrontendIpConfigurationName = "appGatewayFrontendIP",
// FrontendPortName = "port443",
// Protocol = "Https",
// HostName = "iac-lab-api.iac-labs.com",
// RequireSni = true,
// SslCertificateName = "gateway-listener"
// },
// new ApplicationGatewayHttpListenerArgs
// {
// Name = "management-listener",
// FrontendIpConfigurationName = "appGatewayFrontendIP",
// FrontendPortName = "port443",
// Protocol = "Https",
// HostName = "iac-lab-management.iac-labs.com",
// RequireSni = true,
// SslCertificateName = "gateway-listener"
// },
// new ApplicationGatewayHttpListenerArgs
// {
// Name = "portal-listener",
// FrontendIpConfigurationName = "appGatewayFrontendIP",
// FrontendPortName = "port443",
// Protocol = "Https",
// HostName = "iac-lab-portal.iac-labs.com",
// RequireSni = true,
// SslCertificateName = "gateway-listener"
// }
// },
// BackendAddressPools = new[]
// {
// new ApplicationGatewayBackendAddressPoolArgs
// {
// Name = "apim-backend-pool",
// IpAddresses = config.RequireSecret("apim.backend.ip")
// }
// },
// Probes = new[]
// {
// new ApplicationGatewayProbeArgs
// {
// Name = "apim-probe",
// Protocol = "Https",
// Path = "/status-0123456789abcdef",
// Host = "iac-lab-api.iac-labs.com",
// Interval = 30,
// Timeout = 120,
// UnhealthyThreshold = 8,
// PickHostNameFromBackendHttpSettings = false,
// MinimumServers = 0
// }
// },
// BackendHttpSettings = new []
// {
// new ApplicationGatewayBackendHttpSettingArgs
// {
// Name = "apim-settings",
// Port = 443,
// Protocol = "Https",
// CookieBasedAffinity = "Disabled",
// PickHostNameFromBackendAddress = false,
// RequestTimeout = 30,
// ProbeName = "apim-probe"
// }
// },
// RequestRoutingRules = new[]
// {
// new ApplicationGatewayRequestRoutingRuleArgs
// {
// Name = "gateway",
// RuleType = "Basic",
// HttpListenerName = "gateway-listener",
// BackendAddressPoolName = "apim-backend-pool",
// BackendHttpSettingsName = "apim-settings"
// },
// new ApplicationGatewayRequestRoutingRuleArgs
// {
// Name = "management",
// RuleType = "Basic",
// HttpListenerName = "management-listener",
// BackendAddressPoolName = "apim-backend-pool",
// BackendHttpSettingsName = "apim-settings"
// },
// new ApplicationGatewayRequestRoutingRuleArgs
// {
// Name = "portal",
// RuleType = "Basic",
// HttpListenerName = "portal-listener",
// BackendAddressPoolName = "apim-backend-pool",
// BackendHttpSettingsName = "apim-settings"
// },
// }
// });
//
// var appInsight = new Insights("ai", new InsightsArgs
// {
// Name = NamingConvention.GetAppInsightName(environment),
// ResourceGroupName = resourceGroup.Name,
// Location = resourceGroup.Location,
// ApplicationType = "web",
//
// });
// var la = new AnalyticsWorkspace("la", new AnalyticsWorkspaceArgs
// {
// Name = NamingConvention.GetLogAnalyticsName(environment),
// ResourceGroupName = resourceGroup.Name,
// Location = resourceGroup.Location,
// Sku = "PerGB2018"
// });
var aksEgressPublicIp = new PublicIp("aks-egress-pip", new PublicIpArgs
{
Name = NamingConvention.GetPublicIpName("aks-egress", environment),
ResourceGroupName = resourceGroup.Name,
Sku = "Standard",
AllocationMethod = "Static"
});
var logAnalyticsWorkspaceId = baseStack.RequireOutput("LogAnalyticsWorkspaceId").Apply(x => x.ToString());
var aks = new KubernetesCluster("aks", new KubernetesClusterArgs
{
Name = NamingConvention.GetAksName(environment),
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
Identity = new KubernetesClusterIdentityArgs
{
Type = "SystemAssigned"
},
DefaultNodePool = new KubernetesClusterDefaultNodePoolArgs
{
Name = "aksagentpool",
NodeCount = 1,
VmSize = "Standard_B2s",
OsDiskSizeGb = 30,
VnetSubnetId = aksSubnet.Id
},
DnsPrefix = "iacpulumiaks",
RoleBasedAccessControl = new KubernetesClusterRoleBasedAccessControlArgs
{
Enabled = true,
AzureActiveDirectory = new KubernetesClusterRoleBasedAccessControlAzureActiveDirectoryArgs
{
AdminGroupObjectIds = config.RequireSecret("teamPlatformAADId"),
TenantId = config.RequireSecret("tenantId"),
Managed = true
}
},
NetworkProfile = new KubernetesClusterNetworkProfileArgs
{
NetworkPlugin = "azure",
NetworkPolicy = "calico",
DnsServiceIp = "10.2.2.254",
ServiceCidr = "10.2.2.0/24",
DockerBridgeCidr = "172.17.0.1/16",
LoadBalancerProfile = new KubernetesClusterNetworkProfileLoadBalancerProfileArgs
{
OutboundIpAddressIds = new []
{
aksEgressPublicIp.Id
}
}
},
AddonProfile = new KubernetesClusterAddonProfileArgs
{
OmsAgent = new KubernetesClusterAddonProfileOmsAgentArgs
{
Enabled = true,
LogAnalyticsWorkspaceId = logAnalyticsWorkspaceId
},
KubeDashboard = new KubernetesClusterAddonProfileKubeDashboardArgs
{
Enabled = false
}
}
});
var pool = new KubernetesClusterNodePool("workload-pool", new KubernetesClusterNodePoolArgs
{
Name = "workload",
KubernetesClusterId = aks.Id,
Mode = "User",
NodeCount = 1,
VmSize = "Standard_B2s",
OsDiskSizeGb = 30,
VnetSubnetId = aksSubnet.Id,
NodeLabels =
{
{ "disk", "ssd" },
{ "type", "workload" }
}
});
this.KubeConfig = aks.KubeConfigRaw;
}
/// <summary>
/// Creates or updates a virtual network in the specified resource group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkName'>
/// The name of the virtual network.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the create or update virtual network operation
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <VirtualNetwork> BeginCreateOrUpdateAsync(this IVirtualNetworksOperations operations, string resourceGroupName, string virtualNetworkName, VirtualNetwork parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, virtualNetworkName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates or updates a virtual network in the specified resource group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkName'>
/// The name of the virtual network.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the create or update virtual network operation
/// </param>
public static VirtualNetwork BeginCreateOrUpdate(this IVirtualNetworksOperations operations, string resourceGroupName, string virtualNetworkName, VirtualNetwork parameters)
{
return(operations.BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkName, parameters).GetAwaiter().GetResult());
}
public async Task NegotiateStream_StreamToStream_Authentication_EmptyCredentials_Fails()
{
string targetName = "testTargetName";
// Ensure there is no confusion between DefaultCredentials / DefaultNetworkCredentials and a
// NetworkCredential object with empty user, password and domain.
NetworkCredential emptyNetworkCredential = new NetworkCredential("", "", "");
Assert.NotEqual(emptyNetworkCredential, CredentialCache.DefaultCredentials);
Assert.NotEqual(emptyNetworkCredential, CredentialCache.DefaultNetworkCredentials);
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated);
Assert.False(server.IsAuthenticated);
Task[] auth = new Task[2];
auth[0] = AuthenticateAsClientAsync(client, emptyNetworkCredential, targetName);
auth[1] = AuthenticateAsServerAsync(server);
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(auth);
// Expected Client property values:
Assert.True(client.IsAuthenticated);
Assert.Equal(TokenImpersonationLevel.Identification, client.ImpersonationLevel);
Assert.Equal(true, client.IsEncrypted);
Assert.Equal(false, client.IsMutuallyAuthenticated);
Assert.Equal(false, client.IsServer);
Assert.Equal(true, client.IsSigned);
Assert.Equal(false, client.LeaveInnerStreamOpen);
IIdentity serverIdentity = client.RemoteIdentity;
Assert.Equal("NTLM", serverIdentity.AuthenticationType);
Assert.Equal(true, serverIdentity.IsAuthenticated);
Assert.Equal(targetName, serverIdentity.Name);
// Expected Server property values:
Assert.True(server.IsAuthenticated);
Assert.Equal(TokenImpersonationLevel.Identification, server.ImpersonationLevel);
Assert.Equal(true, server.IsEncrypted);
Assert.Equal(false, server.IsMutuallyAuthenticated);
Assert.Equal(true, server.IsServer);
Assert.Equal(true, server.IsSigned);
Assert.Equal(false, server.LeaveInnerStreamOpen);
IIdentity clientIdentity = server.RemoteIdentity;
Assert.Equal("NTLM", clientIdentity.AuthenticationType);
// TODO #5241: Behavior difference:
Assert.Equal(false, clientIdentity.IsAuthenticated);
// On .NET Desktop: Assert.Equal(true, clientIdentity.IsAuthenticated);
IdentityValidator.AssertHasName(clientIdentity, new SecurityIdentifier(WellKnownSidType.AnonymousSid, null).Translate(typeof(NTAccount)).Value);
}
}
public async Task NewCode()
{
#endif
var armClient = new ArmClient(new DefaultAzureCredential());
var location = AzureLocation.WestUS;
// Create ResourceGroup
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ArmOperation<ResourceGroup> rgOperation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, "myResourceGroup", new ResourceGroupData(location));
ResourceGroup resourceGroup = rgOperation.Value;
// Create AvailabilitySet
var availabilitySetData = new AvailabilitySetData(location)
{
PlatformUpdateDomainCount = 5,
PlatformFaultDomainCount = 2,
Sku = new ComputeSku() { Name = "Aligned" }
};
ArmOperation<AvailabilitySet> asetOperation = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(WaitUntil.Completed, "myAvailabilitySet", availabilitySetData);
AvailabilitySet availabilitySet = asetOperation.Value;
// Create VNet
var vnetData = new VirtualNetworkData()
{
Location = location,
Subnets =
{
new SubnetData()
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
}
},
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation<VirtualNetwork> vnetOperation = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualNetwork", vnetData);
VirtualNetwork vnet = vnetOperation.Value;
// Create Network interface
var nicData = new NetworkInterfaceData()
{
Location = location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData() { Id = vnet.Data.Subnets.First().Id },
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
}
}
};
ArmOperation<NetworkInterface> nicOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(WaitUntil.Completed, "myNetworkInterface", nicData);
NetworkInterface nic = nicOperation.Value;
var vmData = new VirtualMachineData(location)
{
AvailabilitySet = new WritableSubResource() { Id = availabilitySet.Id },
NetworkProfile = new Compute.Models.NetworkProfile { NetworkInterfaces = { new NetworkInterfaceReference() { Id = nic.Id } } },
OSProfile = new OSProfile
{
ComputerName = "testVM",
AdminUsername = "******",
AdminPassword = "******",
LinuxConfiguration = new LinuxConfiguration { DisablePasswordAuthentication = false, ProvisionVmAgent = true }
},
StorageProfile = new StorageProfile()
{
ImageReference = new ImageReference()
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "18.04-LTS",
Version = "latest"
}
},
HardwareProfile = new HardwareProfile() { VmSize = VirtualMachineSizeTypes.StandardB1Ms },
};
ArmOperation<VirtualMachine> vmOperation = await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualMachine", vmData);
VirtualMachine vm = vmOperation.Value;
#endregion
}
/// <summary>
/// The Put VirtualNetwork operation creates/updates a virtual network in the
/// specified resource group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkName'>
/// The name of the virtual network.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the create/update Virtual Network operation
/// </param>
public static VirtualNetwork BeginCreateOrUpdate(this IVirtualNetworksOperations operations, string resourceGroupName, string virtualNetworkName, VirtualNetwork parameters)
{
return(Task.Factory.StartNew(s => ((IVirtualNetworksOperations)s).BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkName, parameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public void NegotiateStream_StreamToStream_Authentication_EmptyCredentials_Fails()
{
string targetName = "testTargetName";
// Ensure there is no confusion between DefaultCredentials / DefaultNetworkCredentials and a
// NetworkCredential object with empty user, password and domain.
NetworkCredential emptyNetworkCredential = new NetworkCredential("", "", "");
Assert.NotEqual(emptyNetworkCredential, CredentialCache.DefaultCredentials);
Assert.NotEqual(emptyNetworkCredential, CredentialCache.DefaultNetworkCredentials);
VirtualNetwork network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
Assert.False(client.IsAuthenticated);
Assert.False(server.IsAuthenticated);
Task[] auth = new Task[2];
auth[0] = client.AuthenticateAsClientAsync(emptyNetworkCredential, targetName);
auth[1] = server.AuthenticateAsServerAsync();
bool finished = Task.WaitAll(auth, TestConfiguration.PassingTestTimeoutMilliseconds);
Assert.True(finished, "Handshake completed in the allotted time");
// Expected Client property values:
Assert.True(client.IsAuthenticated);
Assert.Equal(TokenImpersonationLevel.Identification, client.ImpersonationLevel);
Assert.Equal(true, client.IsEncrypted);
Assert.Equal(false, client.IsMutuallyAuthenticated);
Assert.Equal(false, client.IsServer);
Assert.Equal(true, client.IsSigned);
Assert.Equal(false, client.LeaveInnerStreamOpen);
IIdentity serverIdentity = client.RemoteIdentity;
Assert.Equal("NTLM", serverIdentity.AuthenticationType);
Assert.Equal(true, serverIdentity.IsAuthenticated);
Assert.Equal(targetName, serverIdentity.Name);
// Expected Server property values:
Assert.True(server.IsAuthenticated);
Assert.Equal(TokenImpersonationLevel.Identification, server.ImpersonationLevel);
Assert.Equal(true, server.IsEncrypted);
Assert.Equal(false, server.IsMutuallyAuthenticated);
Assert.Equal(true, server.IsServer);
Assert.Equal(true, server.IsSigned);
Assert.Equal(false, server.LeaveInnerStreamOpen);
IIdentity clientIdentity = server.RemoteIdentity;
Assert.Equal("NTLM", clientIdentity.AuthenticationType);
// TODO #5241: Behavior difference:
Assert.Equal(false, clientIdentity.IsAuthenticated);
// On .Net Desktop: Assert.Equal(true, clientIdentity.IsAuthenticated);
IdentityValidator.AssertHasName(clientIdentity, @"NT AUTHORITY\ANONYMOUS LOGON");
}
}
public MyStack()
{
var tags = new InputMap <string> {
{ "resourceType", "Service Fabric" },
{ "clusterName", "thepulsf" }
};
// Create an Azure Resource Group
var resourceGroup = new ResourceGroup("resourceGroup", new ResourceGroupArgs
{
ResourceGroupName = "apulsf",
Location = "SoutheastAsia",
Tags = tags,
});
// Create a Storage Account for Log
var storageAccountLog = new StorageAccount("saLog", new StorageAccountArgs
{
ResourceGroupName = resourceGroup.Name,
AccountName = "sflogstore",
Location = resourceGroup.Location,
Sku = new SkuArgs
{
Name = "Standard_LRS",
Tier = "Standard"
},
Kind = "StorageV2",
Tags = tags,
});
// Create a Storage Account for Application Diagnostics
var storageAccountAppDx = new StorageAccount("saAppDx", new StorageAccountArgs
{
ResourceGroupName = resourceGroup.Name,
AccountName = "sfappdxstore",
Location = resourceGroup.Location,
Sku = new SkuArgs
{
Name = "Standard_LRS",
Tier = "Standard"
},
Kind = "StorageV2",
Tags = tags,
});
// Virtual Network
var vnet = new VirtualNetwork("vnet", new VirtualNetworkArgs {
ResourceGroupName = resourceGroup.Name,
VirtualNetworkName = "thevnet4sf",
Location = resourceGroup.Location,
AddressSpace = new nwin.AddressSpaceArgs {
AddressPrefixes = "10.10.0.0/16",
},
Subnets =
{
new nwin.SubnetArgs {
Name = "Subnet0",
AddressPrefix = "10.10.10.0/24",
}
},
Tags = tags,
});
// Public IP Address
var pubIpAddr = new PublicIPAddress("pubip4sf", new PublicIPAddressArgs {
ResourceGroupName = resourceGroup.Name,
PublicIpAddressName = "thesfpubip",
Location = resourceGroup.Location,
DnsSettings = new nwin.PublicIPAddressDnsSettingsArgs {
DomainNameLabel = "thepulsf",
},
PublicIPAllocationMethod = "Dynamic",
Tags = tags,
});
// Load Balancer
var loadBalancer = new LoadBalancer("lb", new LoadBalancerArgs {
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
LoadBalancerName = "thepulsflb4set0",
FrontendIPConfigurations = new nwin.FrontendIPConfigurationArgs {
Name = "lbipconfig",
PublicIPAddress = new nwin.PublicIPAddressArgs {
Id = pubIpAddr.Id,
},
},
Tags = tags,
});
var bepool0 = new lb.BackendAddressPool("bepool0", new lb.BackendAddressPoolArgs {
Name = "bepool0",
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
});
var lbPorts = new [] { 19000, 19080, 80, 443 };
for (int i = 0; i < lbPorts.Length; i++)
{
var port = lbPorts[i];
var probe = new lb.Probe($"lbProbe{i}", new lb.ProbeArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
Port = port,
IntervalInSeconds = 5,
NumberOfProbes = 2,
Protocol = "tcp",
});
var rule = new lb.Rule($"lbRule{i}", new lb.RuleArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
FrontendIpConfigurationName = "lbipconfig",
FrontendPort = port,
BackendAddressPoolId = bepool0.Id,
BackendPort = port,
IdleTimeoutInMinutes = 5,
EnableFloatingIp = false,
Protocol = "tcp",
});
}
var lbNatPool = new lb.NatPool("lbNatPool", new lb.NatPoolArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
FrontendIpConfigurationName = "lbipconfig",
FrontendPortStart = 3389,
FrontendPortEnd = 4500,
BackendPort = 3389,
Protocol = "tcp",
});
var sfCluster = new Cluster("thesf", new ClusterArgs {
ClusterName = "thesf",
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
AddOnFeatures =
{
"DnsService",
"BackupRestoreService"
},
Certificate = new sfi.CertificateDescriptionArgs {
Thumbprint = "4426C164D9E66C2C813DEEC0486F235C0E933212",
X509StoreName = "My",
},
DiagnosticsStorageAccountConfig = new sfi.DiagnosticsStorageAccountConfigArgs {
BlobEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Blob),
ProtectedAccountKeyName = "StorageAccountKey1",
QueueEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Queue),
StorageAccountName = storageAccountLog.Name,
TableEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Table),
},
FabricSettings =
{
new sfi.SettingsSectionDescriptionArgs {
Parameters =
{
new sfi.SettingsParameterDescriptionArgs {
Name = "SecretEncryptionCertThumbprint",
Value = "4426C164D9E66C2C813DEEC0486F235C0E933212",
},
new sfi.SettingsParameterDescriptionArgs {
Name = "SecretEncryptionCertX509StoreName",
Value = "My",
},
},
Name = "BackupRestoreService",
},
new sfi.SettingsSectionDescriptionArgs {
Parameters =
{
new sfi.SettingsParameterDescriptionArgs {
Name = "ClusterProtectionLevel",
Value = "EncryptAndSign",
},
},
Name = "Security",
},
},
ManagementEndpoint = Output.Format($"https://{pubIpAddr.DnsSettings.Apply(it => it?.Fqdn)}:19080"),
NodeTypes =
{
new sfi.NodeTypeDescriptionArgs {
Name = "Type925",
ApplicationPorts = new sfi.EndpointRangeDescriptionArgs{
StartPort = 20000,
EndPort = 30000,
},
ClientConnectionEndpointPort = 19000,
DurabilityLevel = "Silver",
EphemeralPorts = new sfi.EndpointRangeDescriptionArgs {
StartPort = 49152,
EndPort = 65534,
},
HttpGatewayEndpointPort = 19080,
IsPrimary = true,
VmInstanceCount = 5,
},
},
ReliabilityLevel = "Silver",
UpgradeMode = "Automatic",
VmImage = "Windows",
});
Key1 = GetStorageKey(resourceGroup, storageAccountLog, 0);
Key2 = GetStorageKey(resourceGroup, storageAccountLog, 1);
Input <string> key1 = Key1;
Input <string> key2 = Key2;
var vmScaleSet = new VirtualMachineScaleSet("sfScaleSet", new VirtualMachineScaleSetArgs {
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
VmScaleSetName = "sfScaleSet0",
Sku = new cpi.SkuArgs {
Name = "Standard_D2s_v3",
Capacity = 5,
Tier = "Standard",
},
Overprovision = false,
UpgradePolicy = new cpi.UpgradePolicyArgs {
Mode = "Automatic",
},
VirtualMachineProfile = new cpi.VirtualMachineScaleSetVMProfileArgs {
ExtensionProfile = new cpi.VirtualMachineScaleSetExtensionProfileArgs {
Extensions =
{
new cpi.VirtualMachineScaleSetExtensionArgs {
Name = "Type925_ServiceFabricNode",
Type = "ServiceFabricNode",
TypeHandlerVersion = "1.1",
AutoUpgradeMinorVersion = true,
// EnableAutomaticUpgrade = true, // MUST NOT ENABLED
ProtectedSettings =
{
{ "StorageAccountKey1", key1 },
{ "StorageAccountKey2", key2 },
},
Publisher = "Microsoft.Azure.ServiceFabric",
Settings =
{
// { "id", "thepulsf" },
// { "clusterId", "thepulsf" },
// { "clusterEndpoint", pubIpAddr.DnsSettings.Apply(it => it?.Fqdn) },
{ "clusterEndpoint", sfCluster.ClusterEndpoint },
{ "nodeTypeRef", "Type925" },
{ "dataPath", @"D:\\SvcFab" },
{ "durabilityLevel", "Silver" },
{ "enableParallelJobs", true },
{ "nicPrefixOverride", "10.10.10.0/24" },
{ "certificate", new InputMap <string>
{
{ "thumbprint", "4426C164D9E66C2C813DEEC0486F235C0E933212" },
{ "x509StoreName", "My" },
} },
},
},
new cpi.VirtualMachineScaleSetExtensionArgs {
Name = "VMDiagnosticsVmExt_Set0",
Type = "IaaSDiagnostics",
TypeHandlerVersion = "1.5",
ProtectedSettings =
{
{ "storageAccountName", storageAccountAppDx.Name },
{ "storageAccountKey", GetStorageKey(resourceGroup, storageAccountAppDx, 0) },
{ "storageAccountEndPoint", "https://core.windows.net/" },
},
Publisher = "Microsoft.Azure.Diagnostics",
Settings =
{
{ "WadCfg", new InputMap <object>
{
{ "DiagnosticMonitorConfiguration", new InputMap <object>
{
{ "overallQuotaInMB", "50000" },
{ "EtwProviders", new InputMap <object>
{
{ "EtwEventSourceProviderConfiguration", new InputList <InputMap <object> >
{
new InputMap <object>
{
{ "provider", "Microsoft-ServiceFabric-Actors" },
{ "scheduledTransferKeywordFilter", "1" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricReliableActorEventTable" }
} },
},
new InputMap <object>
{
{ "provider", "Microsoft-ServiceFabric-Services" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricReliableServiceEventTable" }
} },
},
} },
{ "EtwManifestProviderConfiguration", new InputList <InputMap <object> >
{
new InputMap <object> {
{ "provider", "cbd93bc2-71e5-4566-b3a7-595d8eeca6e8" },
{ "scheduledTransferLogLevelFilter", "Information" },
{ "scheduledTransferKeywordFilter", "4611686018427387904" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricSystemEventTable" }
} },
}
} },
} },
} },
} },
{ "StorageAccount", storageAccountAppDx.Name },
},
},
},
},
NetworkProfile = new cpi.VirtualMachineScaleSetNetworkProfileArgs {
NetworkInterfaceConfigurations =
{
new cpi.VirtualMachineScaleSetNetworkConfigurationArgs {
Name = "nicSfSet-0",
IpConfigurations =
{
new cpi.VirtualMachineScaleSetIPConfigurationArgs {
Name = "nicSfSet-0",
LoadBalancerBackendAddressPools = new cpi.SubResourceArgs{
Id = bepool0.Id
},
LoadBalancerInboundNatPools = new cpi.SubResourceArgs{
Id = lbNatPool.Id
},
Subnet = new cpi.ApiEntityReferenceArgs {
Id = vnet.Subnets.First().Apply(it => it.Id ?? string.Empty),
},
},
},
Primary = true,
},
},
},
OsProfile = new cpi.VirtualMachineScaleSetOSProfileArgs {
AdminUsername = "******",
AdminPassword = "******",
ComputerNamePrefix = "Type925",
Secrets =
{
new cpi.VaultSecretGroupArgs {
SourceVault = new cpi.SubResourceArgs{
Id = "/subscriptions/5fb1076d-8ce2-4bf8-90af-d53f1b8f8289/resourceGroups/prepkvault/providers/Microsoft.KeyVault/vaults/thekv4sf"
},
VaultCertificates =
{
new cpi.VaultCertificateArgs {
CertificateStore = "My",
CertificateUrl = "https://thekv4sf.vault.azure.net/secrets/thesfcert/4379416a51dc4570bda6bc79a6fbfa59",
},
},
},
},
},
StorageProfile = new cpi.VirtualMachineScaleSetStorageProfileArgs {
ImageReference = new cpi.ImageReferenceArgs {
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2019-Datacenter-with-Containers",
Version = "latest",
},
OsDisk = new cpi.VirtualMachineScaleSetOSDiskArgs {
Caching = "ReadOnly",
CreateOption = "FromImage",
ManagedDisk = new cpi.VirtualMachineScaleSetManagedDiskParametersArgs {
StorageAccountType = "Standard_LRS",
},
},
},
},
});
// Export the primary key of> the Storage Account
this.PrimaryStorageKey = Output.Tuple(resourceGroup.Name, storageAccountAppDx.Name).Apply(names =>
Output.CreateSecret(GetStorageAccountKey(names.Item1, names.Item2, 0)));
}
