fog-azure-rm-temp 0.0.4 → 0.0.5

data/lib/fog/azurerm/docs/compute.md

@@ -1,6 +1,6 @@
 # Compute
 
-This document explains how to get started using Azure Compute Service with Fog. With this gem you can create/update/list/delete availability sets and virtual machines.
+This document explains how to get started using Azure Compute Service with Fog. With this gem you can create, update, list or delete availability sets and virtual machines.
 
 ## Usage 
 
@@ -15,79 +15,119 @@ require 'fog/azurerm'
 Next, create a connection to the Compute Service:
 
 ```ruby
-    azure_compute_service = Fog::Compute.new(
-        provider: 'AzureRM',
-        tenant_id: '<Tenantid>',                                                          # Tenant id of Azure Active Directory Application
-        client_id:    '<Clientid>',                                                       # Client id of Azure Active Directory Application
-        client_secret: '<ClientSecret>',                                                  # Client Secret of Azure Active Directory Application
-        subscription_id: '<Subscriptionid>',                                              # Subscription id of an Azure Account
-        :environment => '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>' # Azure cloud environment. Default is AzureCloud.
+fog_compute_service = Fog::Compute::AzureRM.new(
+      tenant_id:        '<Tenant Id>',                                                             # Tenant Id of Azure Active Directory Application
+      client_id:        '<Client Id>',                                                             # Client Id of Azure Active Directory Application
+      client_secret:    '<Client Secret>',                                                         # Client Secret of Azure Active Directory Application
+      subscription_id:  '<Subscription Id>',                                                       # Subscription Id of an Azure Account
+      environment:      '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'          # Azure cloud environment. Default is AzureCloud.
 )
 ```
 
 ## Check Server Existence
 
 ```ruby
-azure_compute_service.servers.check_vm_exists(<Resource Group name>, <VM Name>)
+fog_compute_service.servers.check_vm_exists('<Resource Group Name>', '<VM Name>')
 ```
 
 ## Create Server
 
-Create a new linux server
-
 **Info:**
-Attribute **network_interface_card_ids** is an array of NICs ids. The NIC id at index zero will become primary NIC of this server(virtual machine) by default.
+
+- Attribute **network_interface_card_ids** is an array of NICs Ids. The NIC Id at index zero will become primary NIC of this server (virtual machine) by default.
+- To create VM with managed OS disk, use the _managed_disk_storage_type_ argument
+- To create VM with unmanaged OS disk, use the _storage_account_name_ argument
+
+### Virtual Machine (Managed OS Disk)
+
+```ruby
+fog_compute_service.servers.create(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        username: '<Username>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                          # Not required if custom image is being used 
+        offer: '<Offer Name>',                                  # Not required if custom image is being used
+        sku: '<SKU Name>',                                      # Not required if custom image is being used
+        version: '<Version>',                                   # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',           # [Optional]
+        password: '<Password>',                                 # [Optional], if 'platform' partameter is 'Linux'.
+        vhd_path: '<Path of VHD>',                              # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                     # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                      # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>',    # [Optional], if storage_account_name is passed, can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>,                              # [Optional], size of the os disk in GB (upto 1023)
+        os_disk_name: '<Disk Name>'                             # [Optional], name of the os disk
+)
+```
 
 **Info:**
-When using **managed_disk_storage_type** you should not pass the **vhd_path** as the managed disk will be used for the OS disk. Also, data disks cannot be attached to a VM which uses managed disks for the OS disk.
+
+- To create VM from Image, pass in the Image ID in `image_ref` attribute
+
+**Limitation:**
+
+- Image should be in the same region
+- ONLY managed VM can be created from image
+
+### Virtual Machine (Managed OS Disk from Image)
 
 ```ruby
-    azure_compute_service.servers.create(
+fog_compute_service.servers.create(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
-        storage_account_name: '<Storage Account Name>',
-        username: '<Username for VM>',
-        password: '<Password for VM>',             # Optional, if 'platform' partameter is 'Linux'.
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'Canonical',                    # Not required if custom image is being used 
-        offer: 'UbuntuServer',                     # Not required if custom image is being used
-        sku: '14.04.2-LTS',                        # Not required if custom image is being used
-        version: 'latest',                         # Not required if custom image is being used
-        platform: 'Linux',
-        vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
-        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
-    )
-```
-
-Create a new windows server
-
-```ruby
-    azure_compute_service.servers.create(
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        username: '<Username>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                          # Not required if custom image is being used 
+        offer: '<Offer Name>',                                  # Not required if custom image is being used
+        sku: '<SKU Name>',                                      # Not required if custom image is being used
+        version: '<Version>',                                   # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',           # [Optional]
+        password: '<Password>',                                 # [Optional], if 'platform' partameter is 'Linux'.
+        image_ref: '<Image ID>',                                # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                     # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                      # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>',    # [Optional], if storage_account_name is passed, can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>,                              # [Optional], size of the os disk in GB (upto 1023)
+        os_disk_name: '<Disk Name>'                             # [Optional], name of the os disk
+)
+```
+
+### Virtual Machine (Unmanaged OS Disk)
+
+```ruby
+fog_compute_service.servers.create(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
         storage_account_name: '<Storage Account Name>',
-        username: '<Username for VM>',
-        password: '<Password for VM>',
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'MicrosoftWindowsServerEssentials',   # Not required if custom image is being used
-        offer: 'WindowsServerEssentials',                # Not required if custom image is being used  
-        sku: 'WindowsServerEssentials',                  # Not required if custom image is being used
-        version: 'latest',                               # Not required if custom image is being used
-        platform: 'Windows',
-        vhd_path: '<Path of VHD>',                       # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',                   # Optional, if you want to add custom data in this VM.
-        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
-    )
+        username: '<Username>',
+        password: '<Password>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                    # Not required if custom image is being used
+        offer: '<Offer Name>',                            # Not required if custom image is being used  
+        sku: '<SKU Name>',                                # Not required if custom image is being used
+        version: '<Version>',                             # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',     # [Optional]
+        vhd_path: '<Path of VHD>',                        # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',               # [Optional], if you want to add custom data in this VM.
+        os_disk_size: <Disk Size>,                        # [Optional], size of the os disk in GB (upto 1023)
+        os_disk_name: '<Disk Name>'                       # [Optional], name of the os disk
+)
 ```
 
 ## Create Server Asynchronously
@@ -95,27 +135,30 @@ Create a new windows server
 Create a new linux server asynchronously
 
 ```ruby
-    async_response = azure_compute_service.servers.create_async(
+async_response = fog_compute_service.servers.create_async(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
         storage_account_name: '<Storage Account Name>',
         username: '<Username for VM>',
-        password: '<Password for VM>',             # Optional, if 'platform' partameter is 'Linux'.
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'Canonical',                    # Not required if custom image is being used 
-        offer: 'UbuntuServer',                     # Not required if custom image is being used
-        sku: '14.04.2-LTS',                        # Not required if custom image is being used
-        version: 'latest',                         # Not required if custom image is being used
-        platform: 'Linux',
-        vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
-        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
-    )
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                       # Not required if custom image is being used 
+        offer: '<Offer Name>',                               # Not required if custom image is being used
+        sku: '<SKU Name>',                                   # Not required if custom image is being used
+        version: '<Version>' ,                               # Not required if custom image is being used
+        platform: '<OS Type>', 
+        availability_set_id: '<Availability Set Id>',        # [Optional]
+        password: '<Password>',                              # [Optional], if 'platform' partameter is 'Linux'.
+        vhd_path: '<Path of VHD>',                           # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                  # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                   # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>', # [Optional], can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>,                           # [Optional], size of the os disk in GB (upto 1023)
+        os_disk_name: '<Disk Name>'                          # [Optional], name of the os disk
+)
 ```
 Following methods are available to handle async respoonse:
 - state
@@ -147,18 +190,18 @@ while 1
  end
 ```
  
-For more information about custom_data; see link: https://msdn.microsoft.com/en-us/library/azure/mt163591.aspx
+For more information about custom_data, see link: https://msdn.microsoft.com/en-us/library/azure/mt163591.aspx
 
 ## List Servers
 
 List servers in a resource group
 
 ```ruby
-    servers  = azure_compute_service.servers(resource_group: '<Resource Group name>')
-    servers.each do |server|
+servers  = fog_compute_service.servers(resource_group: '<Resource Group Name>')
+servers.each do |server|
         puts "#{server.name}"
         puts "#{server.location}"
-    end
+end
 ```
 
 ## Retrieve a single Server
@@ -166,241 +209,295 @@ List servers in a resource group
 Get a single record of Server
 
 ```ruby
-      server = azure_compute_service
-                          .servers(resource_group: '<Resource Group name>')
-                          .get('<Resource Group name>', 'Server name>')
-      puts "#{server.name}"
+server = fog_compute_service
+                  .servers(resource_group: '<Resource Group Name>')
+                  .get('<Resource Group Name>', 'Server Name>')
+puts "#{server.name}"
 ```
 
-## Attach a Data Disk to Server
+## Get a Server's status
 
-Get the server object and attach a Data Disk to it.
+Check the status of a Server
 
+```ruby 
+status = fog_compute_service
+                      .servers
+                      .get('<Resource Group Name>', '<Server Name>')
+                      .vm_status
+puts status
+```
+
+## Start a Server
 ```ruby
-      server.attach_data_disk('<Disk Name>', <Size in GB>, '<Storage Account Name>')
+server.start
 ```
 
-## Detach a Data Disk from Server
+## Power Off a Server
+```ruby
+server.power_off
+```
 
-Get the server object and detach a Data Disk from it.
+## Restart a Server
+```ruby
+server.restart
+```
 
+## Deallocate a Server
 ```ruby
-      server.detach_data_disk('<Disk Name>')
+server.deallocate
 ```
 
-## Get a Server's status
+## Redeploy a Server
+```ruby
+server.redeploy
+```
 
-Check the status of a Server
+## Destroy a single Server
 
-```ruby 
-      status = azure_compute_service
-                          .servers
-                          .get('<Resource Group name>', '<Server name>')
-                          .vm_status
-      puts status
+Get a server object from the get method (described above) and then destroy that server.
+
+```ruby
+server.destroy
 ```
 
-## Destroy a single Server
+## Attach a Data Disk to Server
 
-Get a server object from the get method(described above) and then destroy that server.
+Get the server object and attach a Data Disk to it. The data disk attached is blob based.
 
 ```ruby
-      server.destroy
+server.attach_data_disk('<Disk Name>', <Size in GBs>, '<Storage Account Name>')
 ```
 
-## Check Availability Set Existence
+## Detach a Data Disk from Server
+
+Get the server object and detach a Data Disk from it.
 
 ```ruby
-azure_compute_service.availability_sets.check_availability_set_exists(<Resource Group name>, <Availability Set name>)
+server.detach_data_disk('<Disk Name>')
 ```
 
-## Create Availability Set
+## Create Managed Disk
 
-Create a new availability set
+Create a new Premium Managed Disk
 
 ```ruby
-azure_compute_service.availability_sets.create(
-    name: '<Availability Set name>',
-    location: '<Location>',
-    resource_group: '<Resource Group name>'
-    platform_fault_domain_count: <No of Fault Domains>,     # [Optional] Default => 2
-    platform_update_domain_count: <No of Update Domains>,   # [Optional] Default => 5
-    use_managed_disk: true                                  # [Optional] Possible values true or false
+fog_compute_service.managed_disks.create(
+        name: '<Disk Name>',
+        location: '<Location>',
+        resource_group_name: '<Resource Group Name>',
+        account_type: '<Storage Account Type>',
+        disk_size_gb: <Disk Size in GBs>,
+        creation_data: {
+            create_option: '<Create Option Value>'
+        }
 )
 ```
-## List Availability Sets 
 
-List availability sets in a resource group
+Create a new Standard Managed Disk
 
 ```ruby
-    availability_sets  = azure_compute_service.availability_sets(resource_group: '<Resource Group name>')
-    availability_sets.each do |availability_set|
-        puts "#{availability_set.name}"
-        puts "#{availability_set.location}"
-    end
+fog_compute_service.managed_disks.create(
+        name: '<Disk Name>',
+        location: '<Location>',
+        resource_group_name: '<Resource Group Name>',
+        account_type: '<Storage Account Type>',
+        disk_size_gb: <Disk Size in GBs>,
+        creation_data: {
+            create_option: '<Create Option Value>'
+        }
+)
 ```
 
-## Retrieve a single Availability Set
+## Attach a Managed Data Disk to Server
 
-Get a single record of Availability Set
+Get the server object and attach a Data Disk to it.
 
 ```ruby
-      availability_set = azure_compute_service
-                          .availability_sets
-                          .get('<Resource Group name>','<Availability Set name>')
-        puts "#{availability_set.name}"
+server.attach_managed_disk('<Disk Name>', '<Disk Resource Group Name>')
 ```
 
-## Destroy a single Availability Set
+## Detach a Managed Data Disk from Server
 
-Get an availability set object from the get method and then destroy that availability set.
+Get the server object and detach a Data Disk from it.
 
 ```ruby
-      availability_set.destroy
+server.detach_managed_disk('<Disk Name>')
 ```
 
-## Check Virtual Machine Extension Existence
+## List Managed Disks in a Resource Group
+
+List managed disks in a resource group
 
 ```ruby
-azure_compute_service.virtual_machine_extensions.check_vm_extension_exists(<Resource Group name>, <Virtual Machine Name>, <Extension Name>)
+managed_disks  = fog_compute_service.managed_disks(resource_group: '<Resource Group Name>')
+mnaged_disks.each do |disk|
+      puts "#{disk.name}"
+      puts "#{disk.location}"
+end
 ```
 
-## Create Virtual Machine Extension
+## List Managed Disks in a Subscription
 
-Installs an extension to the specified virtual machine.
+List managed disks in a subscription
 
 ```ruby
-    azure_compute_service.virtual_machine_extensions.create(
-        name: <Extension Name>,
-        resource_group: <Resource Group>,
-        location: <Location>,
-        vm_name: <Virtual Machine Name>, # Extension will be installed on this VM
-        publisher: <Extension publisher>,
-        type: <Extension type>,
-        type_handler_version: <Extension version>,
-        auto_upgrade_minor_version: <true|false>, # Optional
-        settings: {JSON object}, # Format: {"key": "value", "key": {"key": "value"}}
-        protected_settings: {JSON object}
-    )
+fog_compute_service.managed_disks.each do |disk|
+     puts "#{disk.name}"
+     puts "#{disk.location}"
+end
 ```
 
-## Get Extension from Virtual Machine
+## Grant Access to a Managed Disk
 
-Retrieves the given extension from the virtual machine
+Grant access to a managed disk
 
 ```ruby
-    vm_extension = azure_compute_service.virtual_machine_extensions.get(
-        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
-    )
+access_sas = fog_compute_service.managed_disks.grant_access('<Resource Group Name>', '<Disk Name>', '<Access Type>', <Duration in Seconds>)
+puts "Access SAS: #{access_sas}"
 ```
 
-## Update Extension
+## Revoke Access from a Managed Disk
 
-Update the given extension. The attributes that can be modified are
-- auto_upgrade_minor_version
-- settings
-- protected_settings
+Revoke access from a managed disk
 
 ```ruby
-    vm_extension.update(
-        auto_upgrade_minor_version: <true|false>,
-        settings: {JSON object},
-        protected_settings: {JSON object}
-    )
+response = fog_compute_service.managed_disks.revoke_access('<Resource Group Name>', '<Disk Name>')
+puts "Revoke Access response status: #{response.status}"
 ```
 
-## Destroy Extension
+## Check Managed Disk Existence
 
-Destroy the given extension from the virtual machine
+```ruby
+fog_compute_service.managed_disks.check_managed_disk_exists('<Resource Group Name>', '<Disk Name>')
+```
+
+## Retrieve a single Managed Disk
+
+Get a single record of managed disks
 
 ```ruby
-    vm_extension.destroy
+managed_disk = fog_compute_service
+                       .managed_disks
+                       .get('<Resource Group Name>', '<Disk Name>')
+puts "#{managed_disk.name}"
 ```
 
+## Destroy a single Managed Disk
 
-## Create Managed Disk
+Get an managed disk object from the get method and then destroy that managed disk.
 
-Create a new Managed Disk
+```ruby
+managed_disk.destroy
+```
+
+## Check Availability Set Existence
 
 ```ruby
-    azure_compute_service.managed_disks.create(
-        name: 'disk_name',
-        location: 'east us',
-        resource_group_name: 'resource_group_name',
-        account_type: 'Premium_LRS',
-        disk_size_gb: 1023,
-        creation_data: {
-          create_option: 'Empty'
-        }
-    )
+fog_compute_service.availability_sets.check_availability_set_exists('<Resource Group Name>', '<Availability Set Name>')
 ```
 
-## List Managed Disks in a Resource Group
+## Create Availability Set
 
-List managed disks in a resource group
+Create a new availability set
 
 ```ruby
-    managed_disks  = azure_compute_service.managed_disks(resource_group: '<Resource Group name>')
-    mnaged_disks.each do |disk|
-        puts "#{disk.name}"
-        puts "#{disk.location}"
-    end
+fog_compute_service.availability_sets.create(
+    name: '<Availability Set Name>',
+    location: '<Location>',
+    resource_group: '<Resource Group Name>'
+    platform_fault_domain_count: <No of Fault Domains>,     # [Optional] Default => 2
+    platform_update_domain_count: <No of Update Domains>,   # [Optional] Default => 5
+    use_managed_disk: true                                  # [Optional] Possible values true or false
+)
 ```
+## List Availability Sets 
 
-## List Managed Disks in a Subscription
-
-List managed disks in a subscription
+List availability sets in a resource group
 
 ```ruby
-    azure_compute_service.managed_disks.each do |disk|
-        puts "#{disk.name}"
-        puts "#{disk.location}"
-    end
+availability_sets  = fog_compute_service.availability_sets(resource_group: '<Resource Group Name>')
+availability_sets.each do |availability_set|
+     puts "#{availability_set.name}"
+     puts "#{availability_set.location}"
+end
 ```
 
-## Grant Access to a Managed Disk
+## Retrieve a single Availability Set
 
-Grant access to a managed disk
+Get a single record of Availability Set
 
 ```ruby
-    access_sas = azure_compute_service.managed_disks.grant_access('<resource_group_name>', '<disk_name>', 'Read', 1000)
-    puts "Access SAS: #{access_sas}"
+availability_set = fog_compute_service
+                        .availability_sets
+                        .get('<Resource Group Name>','<Availability Set Name>')
+puts "#{availability_set.name}"
 ```
 
-## Revoke Access from a Managed Disk
+## Destroy a single Availability Set
 
-Revoke access from a managed disk
+Get an availability set object from the get method and then destroy that availability set.
 
 ```ruby
-    response = azure_compute_service.managed_disks.revoke_access('<resource_group_name>', '<disk_name>')
-    puts "Revoke Access response status: #{response.status}"
+availability_set.destroy
 ```
 
-## Check Managed Disk Existence
+## Check Virtual Machine Extension Existence
 
 ```ruby
-    azure_compute_service.managed_disks.check_managed_disk_exists(<Resource Group name>, <Disk name>)
+fog_compute_service.virtual_machine_extensions.check_vm_extension_exists('<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>')
 ```
 
-## Retrieve a single Managed Disk
+## Create Virtual Machine Extension
 
-Get a single record of managed disks
+Installs an extension to the specified virtual machine.
 
 ```ruby
-      managed_disk = azure_compute_service
-                          .managed_disks
-                          .get('<Resource Group name>','<Disk name>')
-      puts "#{managed_disk.name}"
+fog_compute_service.virtual_machine_extensions.create(
+        name: '<Extension Name>',
+        resource_group: '<Resource Group Name>',
+        location: '<Location>',
+        vm_name: '<Virtual Machine Name>',            # Extension will be installed on this VM
+        publisher: '<Extension Publisher>',
+        type: '<Extension Type>',
+        type_handler_version: '<Extension Version>',
+        settings: {JSON object},                      # Format: {"key": "value", "key": {"key": "value"}}
+        protected_settings: {JSON object},
+        auto_upgrade_minor_version: <True/False> ,   # Optional
+)
 ```
 
-## Destroy a single Managed Disk
+## Get Extension from Virtual Machine
 
-Get an managed disk object from the get method and then destroy that managed disk.
+Retrieves the given extension from the virtual machine
 
 ```ruby
-      managed_disk.destroy
+vm_extension = fog_compute_service.virtual_machine_extensions.get(
+        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
+)
 ```
 
+## Update Extension
+
+Update the given extension. The attributes that can be modified are
+- auto_upgrade_minor_version
+- settings
+- protected_settings
+
+```ruby
+vm_extension.update(
+        auto_upgrade_minor_version: <True/False>,
+        settings: {JSON object},
+        protected_settings: {JSON object}
+)
+```
+
+## Destroy Extension
+
+Destroy the given extension from the virtual machine
+
+```ruby
+vm_extension.destroy
+```
 
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.