Examples with VirtualMachine com.microsoft.azure.management.compute.VirtualMachine used on opensource projects

Example 11 with VirtualMachine

use of com.microsoft.azure.management.compute.VirtualMachine in project azure-sdk-for-java by Azure.

the class ManageInternalLoadBalancer method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(Azure azure) {
    final String rgName = SdkContext.randomResourceName("rgNEML", 15);
    final String vnetName = SdkContext.randomResourceName("vnet", 24);
    final String loadBalancerName3 = SdkContext.randomResourceName("intlb3" + "-", 18);
    final String loadBalancerName4 = SdkContext.randomResourceName("intlb4" + "-", 18);
    final String privateFrontEndName = loadBalancerName3 + "-BE";
    final String backendPoolName3 = loadBalancerName3 + "-BAP3";
    final int orcaleSQLNodePort = 1521;
    final String httpProbe = "httpProbe";
    final String tcpLoadBalancingRule = "tcpRule";
    final String natRule6000to22forVM3 = "nat6000to22forVM3";
    final String natRule6001to23forVM3 = "nat6001to23forVM3";
    final String natRule6002to22forVM4 = "nat6002to22forVM4";
    final String natRule6003to23forVM4 = "nat6003to23forVM4";
    final String networkInterfaceName3 = SdkContext.randomResourceName("nic3", 24);
    final String networkInterfaceName4 = SdkContext.randomResourceName("nic4", 24);
    final String availSetName = SdkContext.randomResourceName("av2", 24);
    final String vmName3 = SdkContext.randomResourceName("lVM3", 24);
    final String vmName4 = SdkContext.randomResourceName("lVM4", 24);
    final String userName = "tirekicker";
    final String sshKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCfSPC2K7LZcFKEO+/t3dzmQYtrJFZNxOsbVgOVKietqHyvmYGHEC0J2wPdAqQ/63g/hhAEFRoyehM+rbeDri4txB3YFfnOK58jqdkyXzupWqXzOrlKY4Wz9SKjjN765+dqUITjKRIaAip1Ri137szRg71WnrmdP3SphTRlCx1Bk2nXqWPsclbRDCiZeF8QOTi4JqbmJyK5+0UqhqYRduun8ylAwKKQJ1NJt85sYIHn9f1Rfr6Tq2zS0wZ7DHbZL+zB5rSlAr8QyUdg/GQD+cmSs6LvPJKL78d6hMGk84ARtFo4A79ovwX/Fj01znDQkU6nJildfkaolH2rWFG/qttD azjava@javalib.com";
    try {
        //=============================================================
        // Create a virtual network with a frontend and a backend subnets
        System.out.println("Creating virtual network with a frontend and a backend subnets...");
        Network network = azure.networks().define(vnetName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withAddressSpace("172.16.0.0/16").defineSubnet("Front-end").withAddressPrefix("172.16.1.0/24").attach().defineSubnet("Back-end").withAddressPrefix("172.16.3.0/24").attach().create();
        System.out.println("Created a virtual network");
        // Print the virtual network details
        Utils.print(network);
        //=============================================================
        // Create an internal load balancer
        // Create a frontend IP address
        // Two backend address pools which contain network interfaces for the virtual
        //  machines to receive HTTP and HTTPS network traffic from the load balancer
        // Two load balancing rules for HTTP and HTTPS to map public ports on the load
        //  balancer to ports in the backend address pool
        // Two probes which contain HTTP and HTTPS health probes used to check availability
        //  of virtual machines in the backend address pool
        // Two inbound NAT rules which contain rules that map a public port on the load
        //  balancer to a port for a specific virtual machine in the backend address pool
        //  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
        System.out.println("Creating an internal facing load balancer with ...");
        System.out.println("- A private IP address");
        System.out.println("- One backend address pool which contain network interfaces for the virtual\n" + "  machines to receive 1521 network traffic from the load balancer");
        System.out.println("- One load balancing rules for 1521 to map public ports on the load\n" + "  balancer to ports in the backend address pool");
        System.out.println("- One probe which contains HTTP health probe used to check availability\n" + "  of virtual machines in the backend address pool");
        System.out.println("- Two inbound NAT rules which contain rules that map a port on the load\n" + "  balancer to a port for a specific virtual machine in the backend address pool\n" + "  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
        LoadBalancer loadBalancer3 = azure.loadBalancers().define(loadBalancerName3).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).definePrivateFrontend(privateFrontEndName).withExistingSubnet(network, "Back-end").withPrivateIPAddressStatic("172.16.3.5").attach().defineBackend(backendPoolName3).attach().defineHttpProbe("httpProbe").withRequestPath("/").attach().defineLoadBalancingRule(tcpLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(orcaleSQLNodePort).withProbe(httpProbe).withBackend(backendPoolName3).attach().defineInboundNatRule(natRule6000to22forVM3).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6000).withBackendPort(22).attach().defineInboundNatRule(natRule6001to23forVM3).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6001).withBackendPort(23).attach().defineInboundNatRule(natRule6002to22forVM4).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6002).withBackendPort(22).attach().defineInboundNatRule(natRule6003to23forVM4).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6003).withBackendPort(23).attach().create();
        // Print load balancer details
        System.out.println("Created an internal load balancer");
        Utils.print(loadBalancer3);
        //=============================================================
        // Define two network interfaces in the backend subnet
        // associate network interfaces to NAT rules, backend pools
        Creatable<NetworkInterface> networkInterface3Creatable = azure.networkInterfaces().define(networkInterfaceName3).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withExistingPrimaryNetwork(network).withSubnet("Back-end").withPrimaryPrivateIPAddressDynamic().withExistingLoadBalancerBackend(loadBalancer3, backendPoolName3).withExistingLoadBalancerInboundNatRule(loadBalancer3, natRule6000to22forVM3).withExistingLoadBalancerInboundNatRule(loadBalancer3, natRule6001to23forVM3);
        Creatable<NetworkInterface> networkInterface4Creatable = azure.networkInterfaces().define(networkInterfaceName4).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withExistingPrimaryNetwork(network).withSubnet("Back-end").withPrimaryPrivateIPAddressDynamic().withExistingLoadBalancerBackend(loadBalancer3, backendPoolName3).withExistingLoadBalancerInboundNatRule(loadBalancer3, natRule6002to22forVM4).withExistingLoadBalancerInboundNatRule(loadBalancer3, natRule6003to23forVM4);
        //=============================================================
        // Define an availability set
        Creatable<AvailabilitySet> availSet2Definition = azure.availabilitySets().define(availSetName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withFaultDomainCount(2).withUpdateDomainCount(4).withSku(AvailabilitySetSkuTypes.MANAGED);
        //=============================================================
        // Create two virtual machines and assign network interfaces
        System.out.println("Creating two virtual machines in the frontend subnet ...");
        System.out.println("- And assigning network interfaces");
        List<Creatable<VirtualMachine>> virtualMachineCreateables2 = new ArrayList<Creatable<VirtualMachine>>();
        Creatable<VirtualMachine> virtualMachine3Creatable = azure.virtualMachines().define(vmName3).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withNewPrimaryNetworkInterface(networkInterface3Creatable).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).withNewAvailabilitySet(availSet2Definition);
        virtualMachineCreateables2.add(virtualMachine3Creatable);
        Creatable<VirtualMachine> virtualMachine4Creatable = azure.virtualMachines().define(vmName4).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withNewPrimaryNetworkInterface(networkInterface4Creatable).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).withNewAvailabilitySet(availSet2Definition);
        virtualMachineCreateables2.add(virtualMachine4Creatable);
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        Collection<VirtualMachine> virtualMachines = azure.virtualMachines().create(virtualMachineCreateables2).values();
        stopwatch.stop();
        System.out.println("Created 2 Linux VMs: (took " + (stopwatch.getTime() / 1000) + " seconds) ");
        System.out.println();
        // Print virtual machine details
        for (VirtualMachine vm : virtualMachines) {
            Utils.print(vm);
            System.out.println();
        }
        //=============================================================
        // Update a load balancer
        //  configure TCP idle timeout to 15 minutes
        System.out.println("Updating the load balancer ...");
        loadBalancer3.update().updateLoadBalancingRule(tcpLoadBalancingRule).withIdleTimeoutInMinutes(15).parent().apply();
        System.out.println("Update the load balancer with a TCP idle timeout to 15 minutes");
        //=============================================================
        // Create another internal load balancer
        // Create a frontend IP address
        // Two backend address pools which contain network interfaces for the virtual
        //  machines to receive HTTP and HTTPS network traffic from the load balancer
        // Two load balancing rules for HTTP and HTTPS to map public ports on the load
        //  balancer to ports in the backend address pool
        // Two probes which contain HTTP and HTTPS health probes used to check availability
        //  of virtual machines in the backend address pool
        // Two inbound NAT rules which contain rules that map a public port on the load
        //  balancer to a port for a specific virtual machine in the backend address pool
        //  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
        System.out.println("Creating another internal facing load balancer with ...");
        System.out.println("- A private IP address");
        System.out.println("- One backend address pool which contain network interfaces for the virtual\n" + "  machines to receive 1521 network traffic from the load balancer");
        System.out.println("- One load balancing rules for 1521 to map public ports on the load\n" + "  balancer to ports in the backend address pool");
        System.out.println("- One probe which contains HTTP health probe used to check availability\n" + "  of virtual machines in the backend address pool");
        System.out.println("- Two inbound NAT rules which contain rules that map a port on the load\n" + "  balancer to a port for a specific virtual machine in the backend address pool\n" + "  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
        LoadBalancer loadBalancer4 = azure.loadBalancers().define(loadBalancerName4).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).definePrivateFrontend(privateFrontEndName).withExistingSubnet(network, "Back-end").withPrivateIPAddressStatic("172.16.3.15").attach().defineBackend(backendPoolName3).attach().defineHttpProbe("httpProbe").withRequestPath("/").attach().defineLoadBalancingRule(tcpLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(orcaleSQLNodePort).withProbe(httpProbe).withBackend(backendPoolName3).attach().defineInboundNatRule(natRule6000to22forVM3).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6000).withBackendPort(22).attach().defineInboundNatRule(natRule6001to23forVM3).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6001).withBackendPort(23).attach().defineInboundNatRule(natRule6002to22forVM4).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6002).withBackendPort(22).attach().defineInboundNatRule(natRule6003to23forVM4).withProtocol(TransportProtocol.TCP).withFrontend(privateFrontEndName).withFrontendPort(6003).withBackendPort(23).attach().create();
        // Print load balancer details
        System.out.println("Created an internal load balancer");
        Utils.print(loadBalancer4);
        //=============================================================
        // List load balancers
        List<LoadBalancer> loadBalancers = azure.loadBalancers().list();
        System.out.println("Walking through the list of load balancers");
        for (LoadBalancer loadBalancer : loadBalancers) {
            Utils.print(loadBalancer);
            System.out.println();
        }
        //=============================================================
        // Remove a load balancer
        System.out.println("Deleting load balancer " + loadBalancerName4 + "(" + loadBalancer4.id() + ")");
        azure.loadBalancers().deleteById(loadBalancer4.id());
        System.out.println("Deleted load balancer" + loadBalancerName4);
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByName(rgName);
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

Example 12 with VirtualMachine

use of com.microsoft.azure.management.compute.VirtualMachine in project azure-sdk-for-java by Azure.

the class ManageInternetFacingLoadBalancer method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(Azure azure) {
    final String rgName = SdkContext.randomResourceName("rgNEML", 15);
    final String vnetName = SdkContext.randomResourceName("vnet", 24);
    final String loadBalancerName1 = SdkContext.randomResourceName("intlb1" + "-", 18);
    final String loadBalancerName2 = SdkContext.randomResourceName("intlb2" + "-", 18);
    final String publicIpName1 = "pip1-" + loadBalancerName1;
    final String publicIpName2 = "pip2-" + loadBalancerName1;
    final String frontendName = loadBalancerName1 + "-FE1";
    final String backendPoolName1 = loadBalancerName1 + "-BAP1";
    final String backendPoolName2 = loadBalancerName1 + "-BAP2";
    final String httpProbe = "httpProbe";
    final String httpsProbe = "httpsProbe";
    final String httpLoadBalancingRule = "httpRule";
    final String httpsLoadBalancingRule = "httpsRule";
    final String natRule5000to22forVM1 = "nat5000to22forVM1";
    final String natRule5001to23forVM1 = "nat5001to23forVM1";
    final String natRule5002to22forVM2 = "nat5002to22forVM2";
    final String natRule5003to23forVM2 = "nat5003to23forVM2";
    final String networkInterfaceName1 = SdkContext.randomResourceName("nic1", 24);
    final String networkInterfaceName2 = SdkContext.randomResourceName("nic2", 24);
    final String availSetName = SdkContext.randomResourceName("av", 24);
    final String userName = "tirekicker";
    final String sshKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCfSPC2K7LZcFKEO+/t3dzmQYtrJFZNxOsbVgOVKietqHyvmYGHEC0J2wPdAqQ/63g/hhAEFRoyehM+rbeDri4txB3YFfnOK58jqdkyXzupWqXzOrlKY4Wz9SKjjN765+dqUITjKRIaAip1Ri137szRg71WnrmdP3SphTRlCx1Bk2nXqWPsclbRDCiZeF8QOTi4JqbmJyK5+0UqhqYRduun8ylAwKKQJ1NJt85sYIHn9f1Rfr6Tq2zS0wZ7DHbZL+zB5rSlAr8QyUdg/GQD+cmSs6LvPJKL78d6hMGk84ARtFo4A79ovwX/Fj01znDQkU6nJildfkaolH2rWFG/qttD azjava@javalib.com";
    try {
        //=============================================================
        // Create a virtual network with a frontend and a backend subnets
        System.out.println("Creating virtual network with a frontend and a backend subnets...");
        Network network = azure.networks().define(vnetName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withAddressSpace("172.16.0.0/16").defineSubnet("Front-end").withAddressPrefix("172.16.1.0/24").attach().defineSubnet("Back-end").withAddressPrefix("172.16.3.0/24").attach().create();
        System.out.println("Created a virtual network");
        // Print the virtual network details
        Utils.print(network);
        //=============================================================
        // Create a public IP address
        System.out.println("Creating a public IP address...");
        PublicIPAddress publicIPAddress = azure.publicIPAddresses().define(publicIpName1).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withLeafDomainLabel(publicIpName1).create();
        System.out.println("Created a public IP address");
        // Print the virtual network details
        Utils.print(publicIPAddress);
        //=============================================================
        // Create an Internet facing load balancer
        // Create a frontend IP address
        // Two backend address pools which contain network interfaces for the virtual
        //  machines to receive HTTP and HTTPS network traffic from the load balancer
        // Two load balancing rules for HTTP and HTTPS to map public ports on the load
        //  balancer to ports in the backend address pool
        // Two probes which contain HTTP and HTTPS health probes used to check availability
        //  of virtual machines in the backend address pool
        // Two inbound NAT rules which contain rules that map a public port on the load
        //  balancer to a port for a specific virtual machine in the backend address pool
        //  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
        System.out.println("Creating a Internet facing load balancer with ...");
        System.out.println("- A frontend IP address");
        System.out.println("- Two backend address pools which contain network interfaces for the virtual\n" + "  machines to receive HTTP and HTTPS network traffic from the load balancer");
        System.out.println("- Two load balancing rules for HTTP and HTTPS to map public ports on the load\n" + "  balancer to ports in the backend address pool");
        System.out.println("- Two probes which contain HTTP and HTTPS health probes used to check availability\n" + "  of virtual machines in the backend address pool");
        System.out.println("- Two inbound NAT rules which contain rules that map a public port on the load\n" + "  balancer to a port for a specific virtual machine in the backend address pool\n" + "  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
        LoadBalancer loadBalancer1 = azure.loadBalancers().define(loadBalancerName1).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).definePublicFrontend(frontendName).withExistingPublicIPAddress(publicIPAddress).attach().defineBackend(backendPoolName1).attach().defineBackend(backendPoolName2).attach().defineHttpProbe(httpProbe).withRequestPath("/").withPort(80).attach().defineHttpProbe(httpsProbe).withRequestPath("/").withPort(443).attach().defineLoadBalancingRule(httpLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(80).withProbe(httpProbe).withBackend(backendPoolName1).attach().defineLoadBalancingRule(httpsLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(443).withProbe(httpsProbe).withBackend(backendPoolName2).attach().defineInboundNatRule(natRule5000to22forVM1).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5000).withBackendPort(22).attach().defineInboundNatRule(natRule5001to23forVM1).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5001).withBackendPort(23).attach().defineInboundNatRule(natRule5002to22forVM2).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5002).withBackendPort(22).attach().defineInboundNatRule(natRule5003to23forVM2).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5003).withBackendPort(23).attach().create();
        // Print load balancer details
        System.out.println("Created a load balancer");
        Utils.print(loadBalancer1);
        //=============================================================
        // Define two network interfaces in the frontend subnet
        // associate network interfaces to NAT rules, backend pools
        System.out.println("Creating two network interfaces in the frontend subnet ...");
        System.out.println("- And associating network interfaces to backend pools and NAT rules");
        List<Creatable<NetworkInterface>> networkInterfaceCreatables = new ArrayList<Creatable<NetworkInterface>>();
        Creatable<NetworkInterface> networkInterface1Creatable = azure.networkInterfaces().define(networkInterfaceName1).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withExistingPrimaryNetwork(network).withSubnet("Front-end").withPrimaryPrivateIPAddressDynamic().withExistingLoadBalancerBackend(loadBalancer1, backendPoolName1).withExistingLoadBalancerBackend(loadBalancer1, backendPoolName2).withExistingLoadBalancerInboundNatRule(loadBalancer1, natRule5000to22forVM1).withExistingLoadBalancerInboundNatRule(loadBalancer1, natRule5001to23forVM1);
        networkInterfaceCreatables.add(networkInterface1Creatable);
        Creatable<NetworkInterface> networkInterface2Creatable = azure.networkInterfaces().define(networkInterfaceName2).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withExistingPrimaryNetwork(network).withSubnet("Front-end").withPrimaryPrivateIPAddressDynamic().withExistingLoadBalancerBackend(loadBalancer1, backendPoolName1).withExistingLoadBalancerBackend(loadBalancer1, backendPoolName2).withExistingLoadBalancerInboundNatRule(loadBalancer1, natRule5002to22forVM2).withExistingLoadBalancerInboundNatRule(loadBalancer1, natRule5003to23forVM2);
        networkInterfaceCreatables.add(networkInterface2Creatable);
        //=============================================================
        // Define an availability set
        Creatable<AvailabilitySet> availSet1Definition = azure.availabilitySets().define(availSetName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).withFaultDomainCount(2).withUpdateDomainCount(4).withSku(AvailabilitySetSkuTypes.MANAGED);
        //=============================================================
        // Create two virtual machines and assign network interfaces
        System.out.println("Creating two virtual machines in the frontend subnet ...");
        System.out.println("- And assigning network interfaces");
        List<Creatable<VirtualMachine>> virtualMachineCreateables1 = new ArrayList<Creatable<VirtualMachine>>();
        for (Creatable<NetworkInterface> nicDefinition : networkInterfaceCreatables) {
            virtualMachineCreateables1.add(azure.virtualMachines().define(SdkContext.randomResourceName("lVM1", 24)).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withNewPrimaryNetworkInterface(nicDefinition).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).withNewAvailabilitySet(availSet1Definition));
        }
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        Collection<VirtualMachine> virtualMachines = azure.virtualMachines().create(virtualMachineCreateables1).values();
        stopwatch.stop();
        System.out.println("Created 2 Linux VMs: (took " + (stopwatch.getTime() / 1000) + " seconds) ");
        System.out.println();
        // Print virtual machine details
        for (VirtualMachine vm : virtualMachines) {
            Utils.print(vm);
            System.out.println();
        }
        //=============================================================
        // Update a load balancer
        //  configure TCP idle timeout to 15 minutes
        System.out.println("Updating the load balancer ...");
        loadBalancer1.update().updateLoadBalancingRule(httpLoadBalancingRule).withIdleTimeoutInMinutes(15).parent().updateLoadBalancingRule(httpsLoadBalancingRule).withIdleTimeoutInMinutes(15).parent().apply();
        System.out.println("Update the load balancer with a TCP idle timeout to 15 minutes");
        //=============================================================
        // Create another public IP address
        System.out.println("Creating another public IP address...");
        PublicIPAddress publicIPAddress2 = azure.publicIPAddresses().define(publicIpName2).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withLeafDomainLabel(publicIpName2).create();
        System.out.println("Created another public IP address");
        // Print the virtual network details
        Utils.print(publicIPAddress2);
        //=============================================================
        // Create another Internet facing load balancer
        // Create a frontend IP address
        // Two backend address pools which contain network interfaces for the virtual
        //  machines to receive HTTP and HTTPS network traffic from the load balancer
        // Two load balancing rules for HTTP and HTTPS to map public ports on the load
        //  balancer to ports in the backend address pool
        // Two probes which contain HTTP and HTTPS health probes used to check availability
        //  of virtual machines in the backend address pool
        // Two inbound NAT rules which contain rules that map a public port on the load
        //  balancer to a port for a specific virtual machine in the backend address pool
        //  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
        System.out.println("Creating another Internet facing load balancer with ...");
        System.out.println("- A frontend IP address");
        System.out.println("- Two backend address pools which contain network interfaces for the virtual\n" + "  machines to receive HTTP and HTTPS network traffic from the load balancer");
        System.out.println("- Two load balancing rules for HTTP and HTTPS to map public ports on the load\n" + "  balancer to ports in the backend address pool");
        System.out.println("- Two probes which contain HTTP and HTTPS health probes used to check availability\n" + "  of virtual machines in the backend address pool");
        System.out.println("- Two inbound NAT rules which contain rules that map a public port on the load\n" + "  balancer to a port for a specific virtual machine in the backend address pool\n" + "  - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
        LoadBalancer loadBalancer2 = azure.loadBalancers().define(loadBalancerName2).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).definePublicFrontend(frontendName).withExistingPublicIPAddress(publicIPAddress2).attach().defineBackend(backendPoolName1).attach().defineBackend(backendPoolName2).attach().defineHttpProbe(httpProbe).withRequestPath("/").withPort(80).attach().defineHttpProbe(httpsProbe).withRequestPath("/").withPort(443).attach().defineLoadBalancingRule(httpLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(80).withProbe(httpProbe).withBackend(backendPoolName1).attach().defineLoadBalancingRule(httpsLoadBalancingRule).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(443).withProbe(httpsProbe).withBackend(backendPoolName2).attach().defineInboundNatRule(natRule5000to22forVM1).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5000).withBackendPort(22).attach().defineInboundNatRule(natRule5001to23forVM1).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5001).withBackendPort(23).attach().defineInboundNatRule(natRule5002to22forVM2).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5002).withBackendPort(22).attach().defineInboundNatRule(natRule5003to23forVM2).withProtocol(TransportProtocol.TCP).withFrontend(frontendName).withFrontendPort(5003).withBackendPort(23).attach().create();
        // Print load balancer details
        System.out.println("Created another load balancer");
        Utils.print(loadBalancer2);
        //=============================================================
        // List load balancers
        List<LoadBalancer> loadBalancers = azure.loadBalancers().list();
        System.out.println("Walking through the list of load balancers");
        for (LoadBalancer loadBalancer : loadBalancers) {
            Utils.print(loadBalancer);
        }
        //=============================================================
        // Remove a load balancer
        System.out.println("Deleting load balancer " + loadBalancerName2 + "(" + loadBalancer2.id() + ")");
        azure.loadBalancers().deleteById(loadBalancer2.id());
        System.out.println("Deleted load balancer" + loadBalancerName2);
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByName(rgName);
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

Example 13 with VirtualMachine

use of com.microsoft.azure.management.compute.VirtualMachine in project azure-sdk-for-java by Azure.

the class ManageApplicationGateway method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(Azure azure) {
    final String rgName = SdkContext.randomResourceName("rgNEAG", 15);
    final String pipName = SdkContext.randomResourceName("pip" + "-", 18);
    final String userName = "tirekicker";
    final String sshKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCfSPC2K7LZcFKEO+/t3dzmQYtrJFZNxOsbVgOVKietqHyvmYGHEC0J2wPdAqQ/63g/hhAEFRoyehM+rbeDri4txB3YFfnOK58jqdkyXzupWqXzOrlKY4Wz9SKjjN765+dqUITjKRIaAip1Ri137szRg71WnrmdP3SphTRlCx1Bk2nXqWPsclbRDCiZeF8QOTi4JqbmJyK5+0UqhqYRduun8ylAwKKQJ1NJt85sYIHn9f1Rfr6Tq2zS0wZ7DHbZL+zB5rSlAr8QyUdg/GQD+cmSs6LvPJKL78d6hMGk84ARtFo4A79ovwX/Fj01znDQkU6nJildfkaolH2rWFG/qttD azjava@javalib.com";
    int backendPools = 2;
    int vmCountInAPool = 4;
    Region[] regions = { Region.US_EAST, Region.UK_WEST };
    String[] addressSpaces = { "172.16.0.0/16", "172.17.0.0/16" };
    String[][] publicIpCreatableKeys = new String[backendPools][vmCountInAPool];
    String[][] ipAddresses = new String[backendPools][vmCountInAPool];
    try {
        //=============================================================
        // Create a resource group (Where all resources gets created)
        //
        ResourceGroup resourceGroup = azure.resourceGroups().define(rgName).withRegion(Region.US_EAST).create();
        System.out.println("Created a new resource group - " + resourceGroup.id());
        //=============================================================
        // Create a public IP address for the Application Gateway
        System.out.println("Creating a public IP address for the application gateway ...");
        PublicIPAddress publicIPAddress = azure.publicIPAddresses().define(pipName).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).create();
        System.out.println("Created a public IP address");
        // Print the virtual network details
        Utils.print(publicIPAddress);
        //=============================================================
        // Create backend pools
        // Prepare a batch of Creatable definitions
        List<Creatable<VirtualMachine>> creatableVirtualMachines = new ArrayList<>();
        for (int i = 0; i < backendPools; i++) {
            //=============================================================
            // Create 1 network creatable per region
            // Prepare Creatable Network definition (Where all the virtual machines get added to)
            String networkName = SdkContext.randomResourceName("vnetNEAG-", 20);
            Creatable<Network> networkCreatable = azure.networks().define(networkName).withRegion(regions[i]).withExistingResourceGroup(resourceGroup).withAddressSpace(addressSpaces[i]);
            //=============================================================
            // Create 1 storage creatable per region (For storing VMs disk)
            String storageAccountName = SdkContext.randomResourceName("stgneag", 20);
            Creatable<StorageAccount> storageAccountCreatable = azure.storageAccounts().define(storageAccountName).withRegion(regions[i]).withExistingResourceGroup(resourceGroup);
            String linuxVMNamePrefix = SdkContext.randomResourceName("vm-", 15);
            for (int j = 0; j < vmCountInAPool; j++) {
                //=============================================================
                // Create 1 public IP address creatable
                Creatable<PublicIPAddress> publicIPAddressCreatable = azure.publicIPAddresses().define(String.format("%s-%d", linuxVMNamePrefix, j)).withRegion(regions[i]).withExistingResourceGroup(resourceGroup).withLeafDomainLabel(String.format("%s-%d", linuxVMNamePrefix, j));
                publicIpCreatableKeys[i][j] = publicIPAddressCreatable.key();
                //=============================================================
                // Create 1 virtual machine creatable
                Creatable<VirtualMachine> virtualMachineCreatable = azure.virtualMachines().define(String.format("%s-%d", linuxVMNamePrefix, j)).withRegion(regions[i]).withExistingResourceGroup(resourceGroup).withNewPrimaryNetwork(networkCreatable).withPrimaryPrivateIPAddressDynamic().withNewPrimaryPublicIPAddress(publicIPAddressCreatable).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_DS3_V2).withNewStorageAccount(storageAccountCreatable);
                creatableVirtualMachines.add(virtualMachineCreatable);
            }
        }
        //=============================================================
        // Create two backend pools of virtual machines
        StopWatch stopwatch = new StopWatch();
        System.out.println("Creating virtual machines (two backend pools)");
        stopwatch.start();
        CreatedResources<VirtualMachine> virtualMachines = azure.virtualMachines().create(creatableVirtualMachines);
        stopwatch.stop();
        System.out.println("Created virtual machines (two backend pools)");
        for (VirtualMachine virtualMachine : virtualMachines.values()) {
            System.out.println(virtualMachine.id());
        }
        System.out.println("Virtual machines created: (took " + (stopwatch.getTime() / 1000) + " seconds) to create == " + virtualMachines.size() + " == virtual machines (4 virtual machines per backend pool)");
        //=======================================================================
        // Get IP addresses from created resources
        System.out.println("IP Addresses in the backend pools are - ");
        for (int i = 0; i < backendPools; i++) {
            for (int j = 0; j < vmCountInAPool; j++) {
                PublicIPAddress pip = (PublicIPAddress) virtualMachines.createdRelatedResource(publicIpCreatableKeys[i][j]);
                pip.refresh();
                ipAddresses[i][j] = pip.ipAddress();
                System.out.println(String.format("[backend pool = %d][vm = %d] = %s", i, j, ipAddresses[i][j]));
            }
            System.out.println("======");
        }
        //=======================================================================
        // Create an application gateway
        System.out.println("================= CREATE ======================");
        System.out.println("Creating an application gateway");
        stopwatch.reset();
        stopwatch.start();
        final String sslCertificatePfxPath = ManageApplicationGateway.class.getClassLoader().getResource("myTest._pfx").getPath();
        final String sslCertificatePfxPath2 = ManageApplicationGateway.class.getClassLoader().getResource("myTest2._pfx").getPath();
        ApplicationGateway applicationGateway = azure.applicationGateways().define("myFirstAppGateway").withRegion(Region.US_EAST).withExistingResourceGroup(resourceGroup).defineRequestRoutingRule("HTTP-80-to-8080").fromPublicFrontend().fromFrontendHttpPort(80).toBackendHttpPort(8080).toBackendIPAddress(ipAddresses[0][0]).toBackendIPAddress(ipAddresses[0][1]).toBackendIPAddress(ipAddresses[0][2]).toBackendIPAddress(ipAddresses[0][3]).attach().defineRequestRoutingRule("HTTPs-443-to-8080").fromPublicFrontend().fromFrontendHttpsPort(443).withSslCertificateFromPfxFile(new File(sslCertificatePfxPath)).withSslCertificatePassword("Abc123").toBackendHttpPort(8080).toBackendIPAddress(ipAddresses[1][0]).toBackendIPAddress(ipAddresses[1][1]).toBackendIPAddress(ipAddresses[1][2]).toBackendIPAddress(ipAddresses[1][3]).attach().withExistingPublicIPAddress(publicIPAddress).create();
        stopwatch.stop();
        System.out.println("Application gateway created: (took " + (stopwatch.getTime() / 1000) + " seconds)");
        Utils.print(applicationGateway);
        //=======================================================================
        // Update an application gateway
        // configure the first routing rule for SSL offload
        System.out.println("================= UPDATE ======================");
        System.out.println("Updating the application gateway");
        stopwatch.reset();
        stopwatch.start();
        applicationGateway.update().withoutRequestRoutingRule("HTTP-80-to-8080").defineRequestRoutingRule("HTTPs-1443-to-8080").fromPublicFrontend().fromFrontendHttpsPort(1443).withSslCertificateFromPfxFile(new File(sslCertificatePfxPath2)).withSslCertificatePassword("Abc123").toBackendHttpPort(8080).toBackendIPAddress(ipAddresses[0][0]).toBackendIPAddress(ipAddresses[0][1]).toBackendIPAddress(ipAddresses[0][2]).toBackendIPAddress(ipAddresses[0][3]).withHostName("www.contoso.com").withCookieBasedAffinity().attach().apply();
        stopwatch.stop();
        System.out.println("Application gateway updated: (took " + (stopwatch.getTime() / 1000) + " seconds)");
        Utils.print(applicationGateway);
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByName(rgName);
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

Example 14 with VirtualMachine

use of com.microsoft.azure.management.compute.VirtualMachine in project azure-sdk-for-java by Azure.

the class ManageVirtualMachineWithUnmanagedDisks method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(Azure azure) {
    final Region region = Region.US_WEST_CENTRAL;
    final String windowsVMName = Utils.createRandomName("wVM");
    final String linuxVMName = Utils.createRandomName("lVM");
    final String rgName = Utils.createRandomName("rgCOMV");
    final String userName = "tirekicker";
    final String password = "12NewPA$$w0rd!";
    final String dataDiskName = "disk2";
    try {
        //=============================================================
        // Create a Windows virtual machine
        System.out.println("Creating a Windows VM");
        Date t1 = new Date();
        VirtualMachine windowsVM = azure.virtualMachines().define(windowsVMName).withRegion(region).withNewResourceGroup(rgName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_R2_DATACENTER).withAdminUsername(userName).withAdminPassword(password).withUnmanagedDisks().withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        Date t2 = new Date();
        System.out.println("Created VM: (took " + ((t2.getTime() - t1.getTime()) / 1000) + " seconds) " + windowsVM.id());
        // Print virtual machine details
        Utils.print(windowsVM);
        //=============================================================
        // Update - Tag the virtual machine
        windowsVM.update().withTag("who-rocks", "java").withTag("where", "on azure").apply();
        System.out.println("Tagged VM: " + windowsVM.id());
        //=============================================================
        // Update - Attach data disks
        windowsVM.update().withNewUnmanagedDataDisk(10).defineUnmanagedDataDisk(dataDiskName).withNewVhd(20).withCaching(CachingTypes.READ_WRITE).attach().apply();
        System.out.println("Attached a new data disk" + dataDiskName + " to VM" + windowsVM.id());
        Utils.print(windowsVM);
        //=============================================================
        // Update - detach data disk
        windowsVM.update().withoutUnmanagedDataDisk(dataDiskName).apply();
        System.out.println("Detached data disk " + dataDiskName + " from VM " + windowsVM.id());
        //=============================================================
        // Update - Resize (expand) the data disk
        // First, deallocate the virtual machine and then proceed with resize
        System.out.println("De-allocating VM: " + windowsVM.id());
        windowsVM.deallocate();
        System.out.println("De-allocated VM: " + windowsVM.id());
        VirtualMachineUnmanagedDataDisk dataDisk = windowsVM.unmanagedDataDisks().get(0);
        windowsVM.update().updateUnmanagedDataDisk(dataDisk.name()).withSizeInGB(30).parent().apply();
        System.out.println("Expanded VM " + windowsVM.id() + "'s data disk to 30GB");
        //=============================================================
        // Update - Expand the OS drive size by 10 GB
        int osDiskSizeInGb = windowsVM.osDiskSize();
        if (osDiskSizeInGb == 0) {
            // Server is not returning the OS Disk size, possible bug in server
            System.out.println("Server is not returning the OS disk size, possible bug in the server?");
            System.out.println("Assuming that the OS disk size is 256 GB");
            osDiskSizeInGb = 256;
        }
        windowsVM.update().withOSDiskSizeInGB(osDiskSizeInGb + 10).apply();
        System.out.println("Expanded VM " + windowsVM.id() + "'s OS disk to " + (osDiskSizeInGb + 10));
        //=============================================================
        // Start the virtual machine
        System.out.println("Starting VM " + windowsVM.id());
        windowsVM.start();
        System.out.println("Started VM: " + windowsVM.id() + "; state = " + windowsVM.powerState());
        //=============================================================
        // Restart the virtual machine
        System.out.println("Restarting VM: " + windowsVM.id());
        windowsVM.restart();
        System.out.println("Restarted VM: " + windowsVM.id() + "; state = " + windowsVM.powerState());
        //=============================================================
        // Stop (powerOff) the virtual machine
        System.out.println("Powering OFF VM: " + windowsVM.id());
        windowsVM.powerOff();
        System.out.println("Powered OFF VM: " + windowsVM.id() + "; state = " + windowsVM.powerState());
        // Get the network where Windows VM is hosted
        Network network = windowsVM.getPrimaryNetworkInterface().primaryIPConfiguration().getNetwork();
        //=============================================================
        // Create a Linux VM in the same virtual network
        System.out.println("Creating a Linux VM in the network");
        VirtualMachine linuxVM = azure.virtualMachines().define(linuxVMName).withRegion(region).withExistingResourceGroup(rgName).withExistingPrimaryNetwork(network).withSubnet(// Referencing the default subnet name when no name specified at creation
        "subnet1").withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withRootPassword(password).withUnmanagedDisks().withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        System.out.println("Created a Linux VM (in the same virtual network): " + linuxVM.id());
        Utils.print(linuxVM);
        //=============================================================
        // List virtual machines in the resource group
        String resourceGroupName = windowsVM.resourceGroupName();
        System.out.println("Printing list of VMs =======");
        for (VirtualMachine virtualMachine : azure.virtualMachines().listByResourceGroup(resourceGroupName)) {
            Utils.print(virtualMachine);
        }
        //=============================================================
        // Delete the virtual machine
        System.out.println("Deleting VM: " + windowsVM.id());
        azure.virtualMachines().deleteById(windowsVM.id());
        System.out.println("Deleted VM: " + windowsVM.id());
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByName(rgName);
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

Example 15 with VirtualMachine

use of com.microsoft.azure.management.compute.VirtualMachine in project azure-sdk-for-java by Azure.

the class TestVirtualMachineSizes method createResource.

@Override
public VirtualMachine createResource(VirtualMachines virtualMachines) throws Exception {
    List<VirtualMachineSize> availableSizes = virtualMachines.sizes().listByRegion(Region.US_EAST);
    Assert.assertTrue(availableSizes.size() > 0);
    System.out.println("VM Sizes: " + availableSizes);
    final String vmName = "vm" + this.testId;
    VirtualMachine vm = virtualMachines.define(vmName).withRegion(Region.US_EAST).withNewResourceGroup().withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_R2_DATACENTER).withAdminUsername("testuser").withAdminPassword("12NewPA$$w0rd!").withSize(// Use the first size
    availableSizes.get(0).name()).create();
    Assert.assertTrue(vm.size().toString().equalsIgnoreCase(availableSizes.get(0).name()));
    return vm;
}