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

Example 6 with Disk

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

the class CreateVirtualMachineUsingCustomImageFromVHD 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 linuxVMName1 = SdkContext.randomResourceName("VM1", 10);
    final String linuxVMName2 = SdkContext.randomResourceName("VM2", 10);
    final String linuxVMName3 = SdkContext.randomResourceName("VM3", 10);
    final String customImageName = SdkContext.randomResourceName("img", 10);
    final String rgName = SdkContext.randomResourceName("rgCOMV", 15);
    final String publicIPDnsLabel = SdkContext.randomResourceName("pip", 10);
    final String userName = "tirekicker";
    final String password = "12NewPA$$w0rd!";
    final Region region = Region.US_WEST_CENTRAL;
    final String apacheInstallScript = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/master/azure-samples/src/main/resources/install_apache.sh";
    final String apacheInstallCommand = "bash install_apache.sh";
    List<String> apacheInstallScriptUris = new ArrayList<>();
    apacheInstallScriptUris.add(apacheInstallScript);
    try {
        //=============================================================
        // Create a Linux VM using a PIR image with un-managed OS and data disks and customize virtual
        // machine using custom script extension
        System.out.println("Creating a un-managed Linux VM");
        VirtualMachine linuxVM = azure.virtualMachines().define(linuxVMName1).withRegion(region).withNewResourceGroup(rgName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withNewPrimaryPublicIPAddress(publicIPDnsLabel).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withRootPassword(password).withUnmanagedDisks().defineUnmanagedDataDisk("disk-1").withNewVhd(100).withLun(1).attach().defineUnmanagedDataDisk("disk-2").withNewVhd(50).withLun(2).attach().defineUnmanagedDataDisk("disk-3").withNewVhd(60).withLun(3).attach().defineNewExtension("CustomScriptForLinux").withPublisher("Microsoft.OSTCExtensions").withType("CustomScriptForLinux").withVersion("1.4").withMinorVersionAutoUpgrade().withPublicSetting("fileUris", apacheInstallScriptUris).withPublicSetting("commandToExecute", apacheInstallCommand).attach().withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        System.out.println("Created a Linux VM with un-managed OS and data disks: " + linuxVM.id());
        Utils.print(linuxVM);
        // De-provision the virtual machine
        deprovisionAgentInLinuxVM(linuxVM.getPrimaryPublicIPAddress().fqdn(), 22, userName, password);
        //=============================================================
        // Deallocate the virtual machine
        System.out.println("Deallocate VM: " + linuxVM.id());
        linuxVM.deallocate();
        System.out.println("De-allocated VM: " + linuxVM.id() + "; state = " + linuxVM.powerState());
        //=============================================================
        // Generalize the virtual machine
        System.out.println("Generalize VM: " + linuxVM.id());
        linuxVM.generalize();
        System.out.println("Generalized VM: " + linuxVM.id());
        //=============================================================
        // Create a virtual machine custom image from OS and data disks of the virtual machine
        System.out.println("Creating virtual machine custom image from un-managed disk VHDs: " + linuxVM.id());
        VirtualMachineCustomImage virtualMachineCustomImage = azure.virtualMachineCustomImages().define(customImageName).withRegion(region).withExistingResourceGroup(rgName).withLinuxFromVhd(linuxVM.osUnmanagedDiskVhdUri(), OperatingSystemStateTypes.GENERALIZED).defineDataDiskImage().withLun(linuxVM.unmanagedDataDisks().get(1).lun()).fromVhd(linuxVM.unmanagedDataDisks().get(1).vhdUri()).attach().defineDataDiskImage().withLun(linuxVM.unmanagedDataDisks().get(2).lun()).fromVhd(linuxVM.unmanagedDataDisks().get(2).vhdUri()).attach().defineDataDiskImage().withLun(linuxVM.unmanagedDataDisks().get(3).lun()).fromVhd(linuxVM.unmanagedDataDisks().get(3).vhdUri()).withDiskCaching(CachingTypes.READ_ONLY).attach().create();
        System.out.println("Created custom image");
        Utils.print(virtualMachineCustomImage);
        //=============================================================
        // Create a Linux VM using custom image
        System.out.println("Creating a Linux VM using custom image: " + virtualMachineCustomImage.id());
        VirtualMachine linuxVM2 = azure.virtualMachines().define(linuxVMName2).withRegion(region).withExistingResourceGroup(rgName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withLinuxCustomImage(virtualMachineCustomImage.id()).withRootUsername(userName).withRootPassword(password).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        System.out.println("Created Linux VM");
        Utils.print(linuxVM2);
        //=============================================================
        // Create another Linux VM using custom image and configure the data disks from image and
        // add another data disk
        VirtualMachine linuxVM3 = azure.virtualMachines().define(linuxVMName3).withRegion(region).withExistingResourceGroup(rgName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withLinuxCustomImage(virtualMachineCustomImage.id()).withRootUsername(userName).withRootPassword(password).withNewDataDiskFromImage(1, 200, CachingTypes.READ_WRITE).withNewDataDiskFromImage(2, 100, CachingTypes.READ_ONLY).withNewDataDiskFromImage(3, 100, CachingTypes.READ_WRITE).withNewDataDisk(50).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        Utils.print(linuxVM3);
        // Getting the SAS URIs requires virtual machines to be de-allocated
        // [Access not permitted because'disk' is currently attached to running VM]
        //
        System.out.println("De-allocating the virtual machine - " + linuxVM3.id());
        linuxVM3.deallocate();
        //=============================================================
        // Get the readonly SAS URI to the OS and data disks
        System.out.println("Getting OS and data disks SAS Uris");
        // OS Disk SAS Uri
        Disk osDisk = azure.disks().getById(linuxVM3.osDiskId());
        String osDiskSasUri = osDisk.grantAccess(24 * 60);
        System.out.println("OS disk SAS Uri: " + osDiskSasUri);
        // Data Disks SAS Uri
        for (VirtualMachineDataDisk disk : linuxVM3.dataDisks().values()) {
            Disk dataDisk = azure.disks().getById(disk.id());
            String dataDiskSasUri = dataDisk.grantAccess(24 * 60);
            System.out.println(String.format("Data disk (lun: %d) SAS Uri: %s", disk.lun(), dataDiskSasUri));
        }
        //=============================================================
        // Deleting the custom image
        System.out.println("Deleting custom Image: " + virtualMachineCustomImage.id());
        azure.virtualMachineCustomImages().deleteById(virtualMachineCustomImage.id());
        System.out.println("Deleted custom image");
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().beginDeleteByName(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 7 with Disk

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

the class ManageVirtualMachineAsync 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(final 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 windowsVmKey = "WindowsVM";
    final String linuxVmKey = "LinuxVM";
    try {
        //=============================================================
        // Create a Windows virtual machine
        // Prepare a creatable data disk for VM
        //
        final Date t1 = new Date();
        final Creatable<Disk> dataDiskCreatable = azure.disks().define(Utils.createRandomName("dsk-")).withRegion(region).withExistingResourceGroup(rgName).withData().withSizeInGB(100);
        // Create a data disk to attach to VM
        //
        Observable<Indexable> dataDiskObservable = azure.disks().define(Utils.createRandomName("dsk-")).withRegion(region).withNewResourceGroup(rgName).withData().withSizeInGB(50).createAsync();
        final Map<String, VirtualMachine> createdVms = new TreeMap<>();
        dataDiskObservable.flatMap(new Func1<Indexable, Observable<Indexable>>() {

            @Override
            public Observable<Indexable> call(Indexable createdResource) {
                if (createdResource instanceof Disk) {
                    System.out.println("Creating a Windows VM");
                    return 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).withNewDataDisk(10).withNewDataDisk(dataDiskCreatable).withExistingDataDisk((Disk) createdResource).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).createAsync();
                }
                return Observable.just(createdResource);
            }
        }).flatMap(new Func1<Indexable, Observable<Indexable>>() {

            @Override
            public Observable<Indexable> call(Indexable createdResource) {
                if (createdResource instanceof Network) {
                    // Once Network object is created we can start creation of Linux VM in the same network
                    Network network = (Network) createdResource;
                    System.out.println("Created Network");
                    Utils.print(network);
                    System.out.println("Creating a Linux VM in the same network");
                    return 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).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).createAsync();
                }
                return Observable.just(createdResource);
            }
        }).map(new Func1<Indexable, Indexable>() {

            @Override
            public Indexable call(Indexable createdResource) {
                if (createdResource instanceof VirtualMachine) {
                    Date t2 = new Date();
                    VirtualMachine virtualMachine = (VirtualMachine) createdResource;
                    if (isWindowsVM(virtualMachine)) {
                        createdVms.put(windowsVmKey, virtualMachine);
                        System.out.println("Created Windows VM: " + virtualMachine.id());
                    } else {
                        createdVms.put(linuxVmKey, virtualMachine);
                        System.out.println("Created a Linux VM (in the same virtual network): " + virtualMachine.id());
                    }
                    System.out.println("Virtual machine creation took " + ((t2.getTime() - t1.getTime()) / 1000) + " seconds");
                    // Print virtual machine details
                    Utils.print(virtualMachine);
                }
                return createdResource;
            }
        }).toBlocking().subscribe();
        final VirtualMachine windowsVM = createdVms.get(windowsVmKey);
        final VirtualMachine linuxVM = createdVms.get(linuxVmKey);
        //=============================================================
        // Update virtual machines
        // - Tag the virtual machine on Linux VM
        Observable<VirtualMachine> updateLinuxVMChain = linuxVM.update().withTag("who-rocks-on-linux", "java").withTag("where", "on azure").applyAsync().map(new Func1<VirtualMachine, VirtualMachine>() {

            @Override
            public VirtualMachine call(VirtualMachine virtualMachine) {
                System.out.println("Tagged Linux VM: " + virtualMachine.id());
                return virtualMachine;
            }
        });
        // - Add a data disk on Windows VM.
        Observable<VirtualMachine> updateWindowsVMChain = windowsVM.update().withNewDataDisk(200).applyAsync();
        Observable.merge(updateLinuxVMChain, updateWindowsVMChain).toBlocking().subscribe();
        //=============================================================
        // List virtual machines and print details
        azure.virtualMachines().listByResourceGroupAsync(rgName).map(new Func1<VirtualMachine, VirtualMachine>() {

            @Override
            public VirtualMachine call(VirtualMachine virtualMachine) {
                System.out.println("Retrieved details for VM: " + virtualMachine.id());
                Utils.print(virtualMachine);
                return virtualMachine;
            }
        }).toBlocking().subscribe();
        //=============================================================
        // Delete the virtual machines in parallel
        Observable.merge(azure.virtualMachines().deleteByIdAsync(windowsVM.id()).toObservable(), azure.virtualMachines().deleteByIdAsync(linuxVM.id()).toObservable()).toBlocking().subscribe();
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByNameAsync(rgName).await();
            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 8 with Disk

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

the class ManageVirtualMachineWithDisk 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 linuxVMName1 = Utils.createRandomName("VM1");
    final String rgName = Utils.createRandomName("rgCOMV");
    final String publicIPDnsLabel = Utils.createRandomName("pip");
    final String userName = "tirekicker";
    final String password = "12NewPA$$w0rd!";
    final Region region = Region.US_WEST_CENTRAL;
    try {
        // Creates an empty data disk to attach to the virtual machine
        //
        System.out.println("Creating an empty managed disk");
        Disk dataDisk1 = azure.disks().define(Utils.createRandomName("dsk-")).withRegion(region).withNewResourceGroup(rgName).withData().withSizeInGB(50).create();
        System.out.println("Created managed disk");
        // Prepare first creatable data disk
        //
        Creatable<Disk> dataDiskCreatable1 = azure.disks().define(Utils.createRandomName("dsk-")).withRegion(region).withExistingResourceGroup(rgName).withData().withSizeInGB(100);
        // Prepare second creatable data disk
        //
        Creatable<Disk> dataDiskCreatable2 = azure.disks().define(Utils.createRandomName("dsk-")).withRegion(region).withExistingResourceGroup(rgName).withData().withSizeInGB(50).withSku(DiskSkuTypes.STANDARD_LRS);
        //======================================================================
        // Create a Linux VM using a PIR image with managed OS and Data disks
        System.out.println("Creating a managed Linux VM");
        VirtualMachine linuxVM = azure.virtualMachines().define(linuxVMName1).withRegion(region).withNewResourceGroup(rgName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withNewPrimaryPublicIPAddress(publicIPDnsLabel).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withRootPassword(password).withNewDataDisk(100).withNewDataDisk(100, 1, CachingTypes.READ_WRITE).withNewDataDisk(dataDiskCreatable1).withNewDataDisk(dataDiskCreatable2, 2, CachingTypes.READ_ONLY).withExistingDataDisk(dataDisk1).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).create();
        System.out.println("Created a Linux VM with managed OS and data disks: " + linuxVM.id());
        Utils.print(linuxVM);
        //======================================================================
        // Update the virtual machine by detaching two data disks with lun 3 and 4 and adding one
        System.out.println("Updating Linux VM");
        String lun3DiskId = linuxVM.dataDisks().get(3).id();
        linuxVM.update().withoutDataDisk(3).withoutDataDisk(4).withNewDataDisk(200).apply();
        System.out.println("Updated Linux VM: " + linuxVM.id());
        Utils.print(linuxVM);
        // ======================================================================
        // Delete a managed disk
        Disk disk = azure.disks().getById(lun3DiskId);
        System.out.println("Delete managed disk: " + disk.id());
        azure.disks().deleteByResourceGroup(disk.resourceGroupName(), disk.name());
        System.out.println("Deleted managed disk");
        //======================================================================
        // Deallocate the virtual machine
        System.out.println("De-allocate Linux VM");
        linuxVM.deallocate();
        System.out.println("De-allocated Linux VM");
        //======================================================================
        // Resize the OS and Data Disks
        Disk osDisk = azure.disks().getById(linuxVM.osDiskId());
        List<Disk> dataDisks = new ArrayList<>();
        for (VirtualMachineDataDisk vmDataDisk : linuxVM.dataDisks().values()) {
            Disk dataDisk = azure.disks().getById(vmDataDisk.id());
            dataDisks.add(dataDisk);
        }
        System.out.println("Update OS disk: " + osDisk.id());
        osDisk.update().withSizeInGB(2 * osDisk.sizeInGB()).apply();
        System.out.println("OS disk updated");
        for (Disk dataDisk : dataDisks) {
            System.out.println("Update data disk: " + dataDisk.id());
            dataDisk.update().withSizeInGB(dataDisk.sizeInGB() + 10).apply();
            System.out.println("Data disk updated");
        }
        //======================================================================
        // Starting the virtual machine
        System.out.println("Starting Linux VM");
        linuxVM.start();
        System.out.println("Started Linux VM");
        Utils.print(linuxVM);
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().beginDeleteByName(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;
}