---
title: "Implementing Azure DSC: A Step-by-Step Guide"
description: "Learn how to onboard and apply a simple Azure DSC configuration that installs and starts the Apache web service on an Azure VM."
canonical: "https://adamtheautomator.com/azure-dsc/"
---

# Implementing Azure DSC: A Step-by-Step Guide

> Learn how to onboard and apply a simple Azure DSC configuration that installs and starts the Apache web service on an Azure VM.

Source: https://adamtheautomator.com/azure-dsc/

---

ATA Learning

Tap to hide

[

ATA Learning

](/)

*   [Home](/)
*   [Tutorials](/tutorials/)
*   [Instructors](/author/)
*   [Advertising](/advertising/)
*   [Recommended Resources](/resources/)
*   [About Adam](/about-adam/)

Search for:  

*   [](https://twitter.com/adbertram)
*   [](https://github.com/Adam-the-Automator)
*   [](https://www.linkedin.com/company/adam-the-automator-llc)
*   [](/feed/)

![Implementing Azure DSC: A Step-by-Step Guide](https://adamtheautomator.com/wp-content/uploads/2021/01/How-to-Set-Up-Azure-DSC-on-an-Ubuntu-Linux-VM.jpg)

# Implementing Azure DSC: A Step-by-Step Guide

[![](https://secure.gravatar.com/avatar/4122a8cb07a9edbf3d2bc5b54fe7d21ed3e9a68acb4d978973fa8899c236c06b?s=192&d=mm&r=g)Justin Sylvester](https://adamtheautomator.com/author/justin-s/)6 January 202110 min. read

Categories: [DevOps](/category/devops/)

Tags:[DSC](/tag/dsc/)[Microsoft Azure](/tag/microsoft-azure/)

Table of Contents

*   [Prerequisites](#h-prerequisites)
*   [Assigning Global Variable Values](#h-assigning-global-variable-values)
*   [Allowing Traffic to the Ubuntu VM](#h-allowing-traffic-to-the-ubuntu-vm)
*   [Installing the nx Module](#h-installing-the-nx-module)
*   [Defining the Azure DSC Configuration](#h-defining-the-azure-dsc-configuration)
*   [Importing the Azure DSC Configuration](#h-importing-the-azure-dsc-configuration)
*   [Compiling the Azure DSC Configuration](#h-compiling-the-azure-dsc-configuration)
*   [Verifying the Azure DSC Compilation Status](#h-verifying-the-azure-dsc-compilation-status)
*   [Registering an Azure DSC Node](#h-registering-an-azure-dsc-node)
*   [Verifying the Azure DSC Configuration Status](#h-verifying-the-azure-dsc-configuration-status)
*   [Forcing the Azure DSC Configuration to Apply](#h-forcing-the-azure-dsc-configuration-to-apply)
*   [Next Steps](#h-next-steps)

Azure Automation Desired State Configuration (Azure DSC) functions as a centralized configuration management (CM) service within Microsoft Azure. One of the many benefits of Azure DSC is the ability to apply, monitor, and update configuration using a consistent process across your resources at scale.

Not a reader? Watch this related video tutorial!

**_Not seeing the video? Make sure your ad blocker is disabled._**

In this tutorial, you will learn how to onboard and apply a simple Azure DSC configuration that installs and starts the Apache web service on an Azure Virtual Machine (VM).

**Related:** [_How to Apply DSC Configurations to VMs in Azure ARM Templates_](https://adamtheautomator.com/azure-dsc-2/)

## Prerequisites

If you’d like to follow along with this tutorial, please be sure you have the following:

*   PowerShell. This tutorial will be using Windows [PowerShell version](https://adamtheautomator.com/powershell-version/ "PowerShell version") 5.1.

```powershell
#Obtain PowerShell version information
$PSVersionTable['PSVersion']
```

*   A [_Microsoft Azure Account_](https://adamtheautomator.com/azure-free/).
*   The [_Azure PowerShell_](https://docs.microsoft.com/en-us/powershell/azure/install-az-ps?view=azps-7.3.2&viewFallbackFrom=azps-5.2.0) module installed and authenticated.

**_Related: [Connect-AzAccount: Your Gateway to Azure with PowerShell](https://adamtheautomator.com/connect-azaccount/)_**

*   An [_Azure Automation Account_](https://docs.microsoft.com/en-us/azure/automation/quickstarts/create-account-portal). This tutorial will be using an Azure Automation Account called _dscautouser_.
*   An _[Azure VM](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal)_ with the following:
    *   An Ubuntu operating system. This tutorial will be using Ubuntu 18.04.
    *   A [_Public IP Address_](https://docs.microsoft.com/en-us/azure/virtual-network/ip-services/associate-public-ip-address-vm).
    *   An associated [_Resource Group_](https://docs.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-portal).

This tutorial will be using a Resource Group called _DSC\_RG_ and an Ubuntu VM called _UbuntuDSC_.

## Assigning Global Variable Values

The resource Group name, Automation Account name, and VM name are unique to each environment. This tutorial will be using unique names so let’s first assign each name a variable. Feel free to open up a text editor and do the same if you’d like to copy and paste some code examples directly.

```powershell
#The name of the target Resource Group
#This tutorial will be using a Resource Group by the name of DSC_RG.
$resourceGroupName = 'DSC_RG'

#The name of the Automation Account
#This tutorial will be using an Automation Account by the name of dscautouser.
$automationAccountName = 'dscautouser'

#The name of the target VM
#This tutorial will be using an Ubuntu VM by the name of UbuntuDSC.
$virtualMachineName = 'UbuntuDSC'
```

## Allowing Traffic to the Ubuntu VM

At a point near the end of the tutorial, you’re going to log into the Ubuntu Azure VM and access its Apache web service. To do that, you need access to SSH and HTTP so you’ll need to open up those ports via its [_Network Security Group (NSG)_](https://docs.microsoft.com/en-us/azure/virtual-network/network-security-groups-overview) configuration. To accomplish this:

1.  Open up a browser.

2\. Navigate to [_Network Security Groups_](https://portal.azure.com/#blade/HubsExtension/BrowseResourceBlade/resourceType/Microsoft.Network%2FNetworkSecurityGroups) within the Azure Portal.

3\. Select the NSG attached to your Ubuntu VM. If you don’t know the NSG, run the below PowerShell code snippet. This snippet gets the Ubuntu VM’s network interface id and uses it to output the interface’s associated NSG.

```powershell
#Obtain VM Network Security Group
((Get-AzVM -ResourceGroupName $resourceGroupName -Name $virtualMachineName).networkprofile.networkinterfaces.Id | Get-AzNetworkInterface).NetworkSecurityGroup.Id
```

In the screenshot below, you will see that the NSG attached to this tutorial’s _UbuntuDSC_ VM shows up as **UbuntuDSC-nsg**:

![Azure NSG menu displaying VM NSG selection](https://adamtheautomator.com/wp-content/uploads/2020/12/00_NSG_Menu.png)

Azure NSG menu displaying VM NSG selection

4\. Select **Inbound** **Security Rule** from the menu on the left-hand side of the screen:

![Azure NSG menu displaying Inbound Security Rules selection](https://adamtheautomator.com/wp-content/uploads/2020/12/01_NSG_Inbound_Rules_Menu.png)

Azure NSG menu displaying Inbound Security Rules selection

5\. Select **Add** from the menu:

![Azure Inbound Security Rules menu displaying Add selection](https://adamtheautomator.com/wp-content/uploads/2020/12/02_NSG_Inbound_Rules_Add_Menu-1.png)

Azure Inbound Security Rules menu displaying Add selection

6\. Configure the Inbound Security Rule according to the following sub-bullets:

*   **Source IP Addresses/CIDR Ranges:** Your public-facing IP Address. The following code snippet reaches out to [_https://ifconfig.me/ip_](https://ifconfig.me/ip*) to obtain the local system’s public IP Address.

```powershell
#Obtain your public IP Address
Invoke-RestMethod -Uri 'https://ifconfig.me/ip'
```

*   **Source Port Ranges**: \*
*   **Destination:** Any
*   **Destination Port Ranges:** 22,80
*   **Protocol:** TCP
*   **Action:** Allow
*   **Priority:** Leave as default
*   **Name:** Allow\_Inbound\_SSH\_HTTP

## Installing the nx Module

The _nx_ module contains the [_DSC resources_](https://docs.microsoft.com/en-us/powershell/scripting/dsc/resources/resources?view=powershell-5.1) necessary to compile DSC configuration for Linux nodes. Since the Ubuntu operating system is a Linux distribution, it depends on the availability of these DSC resources. Microsoft conveniently makes them available directly within Azure through their Modules Gallery. To import the _nx_ Module:

1.  Navigate to [_Automation Accounts_](https://portal.azure.com/#blade/HubsExtension/BrowseResource/resourceType/Microsoft.Automation%2FAutomationAccounts) within the Azure Portal.

2\. Select the Automation Account you will be using to implement your configuration. In the screenshot below, you will see that the tutorial’s **dscautouser** Automation Account shows up:

![Automation Account menu displaying Automation Account selection](https://adamtheautomator.com/wp-content/uploads/2020/12/03_Automation_Account.png)

Automation Account menu displaying Automation Account selection

3\. Select **Modules Gallery** from the menu on the left-hand side of the screen:

![Azure Automation Accounts menu displaying Modules Gallery selection](https://adamtheautomator.com/wp-content/uploads/2020/12/04_Automation_Modules_Gallery.png)

Azure Automation Accounts menu displaying Modules Gallery selection

4\. Search for, and select, the **nx** Module:

![Azure Modules Gallery search result displaying nx module selection](https://adamtheautomator.com/wp-content/uploads/2020/12/05_Automation_Modules_Gallery_nx_Module-1.png)

Azure Modules Gallery search result displaying nx module selection

5\. Select **Import** to import the module:

![Azure nx module menu displaying Import selection](https://adamtheautomator.com/wp-content/uploads/2020/12/06_Automation_Modules_Gallery_nx_Module_Import.png)

Azure nx module menu displaying Import selection

The import process may take a few minutes.

## Defining the Azure DSC Configuration

Now that the Linux DSC resources are available within Azure DSC, it’s time to define your configuration.

A DSC configuration is defined within a special [PowerShell function](https://adamtheautomator.com/powershell-functions/ "PowerShell function") that describes the desired state of a target node. The following configuration function installs the apache2 package and starts the apache2 service.

```powershell
#Establish DSC script file to install apache2 package and enable apache2 service
Configuration 'apache2' {
    #Import the nx DSC Resource
    Import-DscResource -ModuleName 'nx'
    Node localhost {
        #Ensure apache2 package is installed
        nxpackage 'apache2' {
            Ensure          = 'Present'
            Name            = 'apache2'
            PackageManager  = 'Apt'
        }
        #Ensure apache2 service is running
        nxService 'apache2' {
            Enabled         = $true
            Name            = 'apache2'
            Controller      = 'init'
            State           = 'running'
        }
    }
}
```

Save the contents of the configuration function as _apache2.ps1_ in a known location on your local system.

> _The filename (apache2.ps1) will be the configuration name within Azure DSC (apache2), and it must match the configuration name (`Configuration 'apache2'`) within your apache2.ps1 script file._

## Importing the Azure DSC Configuration

To make your configuration available within Azure DSC, you first need to import it. The `Import-AzAutomationDscConfiguration` cmdlet imports the DSC configuration from your local system into Azure DSC.

The following code snippet uploads the configuration stored within the _apache2.ps1_ file to the Resource Group _DSC\_RG_ and Automation Account _dscautouser_ in Azure DSC.

*   The `Published` switch ensures that the configuration is imported in a published state and must be used for the `Import-AzAutomationDscConfiguration` cmdlet to succeed.
*   The source path following the `SourcePath` parameter must be the full filesystem path to the script file that contains your DSC configuration.

In the code snippet below, you will see that the filesystem path to this tutorial’s script file is _C:\\DSC\\apache2.ps1_.

```powershell
#Import DSC script file into Azure DSC
#Adjust -SourcePath parameter to match the full filesystem path to your apache2.ps1 file.
Import-AzAutomationDscConfiguration -SourcePath C:\DSC\apache2.ps1 -ResourceGroupName $resourceGroupName -AutomationAccountName $automationAccountName -Published
```

The output should resemble the following:

![Output of Import-AzAutomationDscConfiguration cmdlet](https://adamtheautomator.com/wp-content/uploads/2020/12/07_Import_DSC_Configuration.png)

Output of Import-AzAutomationDscConfiguration cmdlet

## Compiling the Azure DSC Configuration

Once you’ve imported the DSC configuration into Azure DSC, it needs to be compiled into [_Managed Object Format_](https://docs.microsoft.com/en-us/windows/win32/wmisdk/managed-object-format--mof-). The `Start-AzAutomationDscCompilationJob` cmdlet carries out this task for you by forcing your configuration into the required Managed Object Format within Azure DSC.

```powershell
#Force Azure DSC to compile DSC Configuration
Start-AzAutomationDscCompilationJob -ConfigurationName 'apache2' -ResourceGroupName $resourceGroupName -AutomationAccountName $automationAccountName
```

The output should resemble the following:

![Output of Start-AzAutomationDscCompilationJob cmdlet](https://adamtheautomator.com/wp-content/uploads/2020/12/08_Compile_DSC_Configuration.png)

Output of Start-AzAutomationDscCompilationJob cmdlet

## Verifying the Azure DSC Compilation Status

The `Get-AzAutomationDscNodeConfiguration` obtains metadata for compiled node configuration. You will use this cmdlet to verify that your configuration was successfully compiled by keying on the _RollupStatus_ property of the `Get-AzAutomationDscNodeConfiguration` cmdlet’s output.

```powershell
#Obtain metadata for DSC configuration and ensure RollupStatus is Good
Get-AzAutomationDscNodeConfiguration -ResourceGroupName $resourceGroupName -AutomationAccountName $automationAccountName
```

The output should resemble the following. Ensure that the **RollupStatus** property displays as **Good:**

![Output of Get-AzAutomationDscNodeConfiguration displaying Good RollupStatus](https://adamtheautomator.com/wp-content/uploads/2020/12/09_Get_DSC_Configuration_Status.png)

Output of Get-AzAutomationDscNodeConfiguration displaying Good RollupStatus

## Registering an Azure DSC Node

Now that you’ve imported and compiled your configuration, you must register your VM as a node and associate it with your configuration. To register your Ubuntu VM as a node:

1.  Navigate to [_Automation Accounts_](https://portal.azure.com/#blade/HubsExtension/BrowseResource/resourceType/Microsoft.Automation%2FAutomationAccounts) within the Azure Portal.

2\. Select the Automation Account you will be using to implement your configuration. In the screenshot below, you will see that the tutorial’s **dscautouser** Automation Account shows up:

![Automation Account menu displaying Automation Account selection](https://adamtheautomator.com/wp-content/uploads/2020/12/03_Automation_Account-1.png)

Automation Account menu displaying Automation Account selection

3\. Select **State Configuration (DSC)** from the menu on the left-hand side of the screen:

![Automation Account menu displaying State Configuration (DSC) selection](https://adamtheautomator.com/wp-content/uploads/2020/12/10_Automation_State_Configuration_Menu.png)

Automation Account menu displaying State Configuration (DSC) selection

4\. Select **Add** from the menu:

![State Configuration (DSC) menu displaying Add selection](https://adamtheautomator.com/wp-content/uploads/2020/12/11_Automation_State_Configuration__Add_Menu.png)

State Configuration (DSC) menu displaying Add selection

5\. Select your VM from the list. In the screenshot below, you will see that the tutorial’s **UbuntuDSC** VM shows up:

![Azure Add Node menu displaying VM selection](https://adamtheautomator.com/wp-content/uploads/2020/12/12_Automation_State_Configuration_VM_Menu.png)

Azure Add Node menu displaying VM selection

6\. Select **Connect** from the menu:

![Azure Add Node menu displaying Connect selection](https://adamtheautomator.com/wp-content/uploads/2020/12/13_Automation_State_Configuration_VM_Connect_Menu.png)

Azure Add Node menu displaying Connect selection

7\. Select your compiled configuration from the **Node Configuration Name** drop-down menu (**apache2.localhost** if you’re following along). The remaining settings can be left as default for this tutorial. Additional information on the settings has been provided below:

*   **Node Configuration Name:** The name of the node configuration that the VM should be configured to pull from Azure Automation DSC.
*   **Refresh Frequency**: The frequency (in minutes) at which the [_Local Configuration Manager (LCM)_](https://docs.microsoft.com/en-us/powershell/dsc/managing-nodes/metaConfig?view=dsc-1.1&viewFallbackFrom=powershell-5.1) contacts the Azure Automation DSC pull server to download the latest node configuration.
*   **Configuration Mode Frequency:** The frequency (in minutes) at which the background application of DSC attempts to implement the current node configuration on the target node.
*   **Configuration Mode:** Specifies how the configuration is applied to the target node. Possible values include _ApplyOnly_, _ApplyAndMonitor_, and _ApplyAndAutoCorrect_.
*   **Allow Module Override:** Controls whether new configurations that are downloaded from the Azure Automation DSC pull server are allowed to overwrite the old modules already present on the target node.
*   **Reboot Node if Needed:** Specifies whether to reboot the node if needed
*   **Action After Reboot:** Specifies the action to perform after a reboot completes. Possible values are _Continue Configuration_ and _Stop Configuration._

![Azure Registration menu displaying Node Configuration Name selection](https://adamtheautomator.com/wp-content/uploads/2020/12/14_Automation_State_Configuration_VM_Registration_Menu.png)

Azure Registration menu displaying Node Configuration Name selection

8\. Be patient as the process completes. No need to refresh your screen or click **Refresh**, the status will automatically update. Once the process completes, ensure that the status reads **Connected.** If an error occurs, additional [_troubleshooting_](https://docs.microsoft.com/en-us/azure/automation/troubleshoot/desired-state-configuration) may be required.

![Node connection status screen displaying Connected status](https://adamtheautomator.com/wp-content/uploads/2020/12/15_Automation_State_Configuration_VM_Registration_Status.png)

Node connection status screen displaying Connected status

9\. Navigate back to State Configuration (DSC) and note your node’s **Status**. There are three possible **Status** values that a node can report. They are listed below:

*   **Compliant:** Indicates that the node is compliant with the check.
*   **Failed:** Indicates that the configuration failed the check.
*   **Not Compliant:** Indicates that the node is in the ApplyandMonitor [_configuration mode_,](https://docs.microsoft.com/en-us/powershell/dsc/managing-nodes/metaConfig?view=dsc-1.1&viewFallbackFrom=powershell-5.1) and the machine is not in the desired state.

Ensure your node is present with a **Status** of **Compliant.** As you can see below, Azure DSC has registered the tutorial’s Ubuntu VM called **UbuntuDSC** and it is **Compliant**:

![Azure State Configuration (DSC) menu displaying Compliant node](https://adamtheautomator.com/wp-content/uploads/2020/12/16_Automation_State_Configuration_Node_Status.png)

Azure State Configuration (DSC) menu displaying Compliant node

## Verifying the Azure DSC Configuration Status

In the previous section, the final step provided instructions on how to obtain your node’s configuration status. Obtaining your node’s configuration status can also be accomplished using PowerShell. To check a node’s status from the command line, use the `Get-AzAutomationDscNode` cmdlet.

```powershell
#Obtain metadata for DSC node and ensure Status is Compliant
Get-AzAutomationDscNode -NodeConfigurationName 'apache2.localhost' -ResourceGroupName $resourceGroupName -AutomationAccountName $automationAccountName
```

The output should resemble the following:

![Result of Get-AzAutomationDscNode cmdlet](https://adamtheautomator.com/wp-content/uploads/2020/12/17_Automation_State_Configuration_Node_Status.png)

Result of Get-AzAutomationDscNode cmdlet

## Forcing the Azure DSC Configuration to Apply

If you’ve tried to access your Ubuntu VM’s Apache web service and failed, that is because your configuration has not yet been applied. The initial status of _Compliant_ means that your node is registered, and it will receive your DSC configuration at the next check-in.

The check-in interval was defined as the **Configuration Mode** **Frequency** during the node registration process. The default value is **15** minutes:

![Azure Registration menu displaying Configuration Mode Frequency entry](https://adamtheautomator.com/wp-content/uploads/2020/12/1001.png)

Azure Registration menu displaying Configuration Mode Frequency entry

If you’re not willing to wait for the Configuration Mode Frequency interval to elapse, you can force the configuration to apply.

When you configured the Ubuntu VM as a node in Azure DSC, it automatically installed the necessary PowerShell DSC packages for the Linux operating system. These packages enable you to work with your node’s DSC configuration directly from the host. It is possible to [_manually install the PowerShell DSC packages for Linux_](https://github.com/microsoft/PowerShell-DSC-for-Linux), if necessary.

1.  To force the application of a configuration update, SSH into your Ubuntu VM using its public IP address.
2.  Obtain the VM’s public IP address with the `Get-AzPublicIpAddress` PowerShell cmdlet. The following code snippet obtains the Ubuntu VM’s network interface Id and uses it to extract the interface’s IP configuration Id, which is used to filter the `Get-AzPublicIpAddress` cmdlet’s output to identify the VM’s public IP Address.

```powershell
#Obtain network interface Id for VM
$vmNetworkInterfaceId = ((Get-AzVM -ResourceGroupName $resourceGroupName -Name $virtualMachineName).networkprofile.networkinterfaces.Id | Get-AzNetworkInterface).IpConfigurations.Id

#Use the network interface Id to obtain the VM public IP Address
Get-AzPublicIpAddress | Where-Object -FilterScript {$_.IpConfiguration.Id -eq $vmNetworkInterfaceId} | Select-Object -Property IpAddress
```

3\. Now use the public IP Address obtained above to SSH into your Ubuntu VM.

4\. Once SSHed in, run the _PerformRequiredConfigurationChecks.py_ Python script. This script checks the local system’s configuration against the Azure DSC pull server’s required configuration, per the [_LCM meta-configuration settings_](https://docs.microsoft.com/en-us/powershell/dsc/managing-nodes/metaConfig?view=dsc-1.1&viewFallbackFrom=powershell-5.1).

Use the following to run the _PerformRequiredConfigurationChecks.py_ python script on your Ubuntu VM and force your DSC configuration to apply:

```bash
#Force DSC configuration to apply. Run on target system (Ubuntu VM).
sudo /opt/microsoft/dsc/Scripts/PerformRequiredConfigurationChecks.py
```

**ReturnValue=0** is the expected output, and it indicates that the script completed without error.

![Result of PerformRequiredConfigurationChecks.py script](https://adamtheautomator.com/wp-content/uploads/2020/12/99_Force_Configuration.png)

Result of PerformRequiredConfigurationChecks.py script

5\. Verify that the correct configuration is applied with the `GetDscConfiguration.py` python script. The following returns the DSC configuration that is applied to your Ubuntu VM:

```powershell
#Obtain current DSC configuration of node. Run on target system (Ubuntu VM).
sudo /opt/microsoft/dsc/Scripts/GetDscConfiguration.py
```

The expected output is shown below. Look closely and you can see some of the specifics that were defined within the configuration script that was established earlier in this tutorial:

![Result of GetDscConfiguration.py script](https://adamtheautomator.com/wp-content/uploads/2020/12/98_Get_Configuration_Status.png)

Result of GetDscConfiguration.py script

6\. Now validate your hard work by navigating to your new webpage using your Ubuntu VM’s public IP Address. In the code snippet below, you will see that the public IP Address of this tutorial’s Ubuntu VM is 52.188.16.42:

```powershell
#Establish HTTP connection to Ubuntu VM's public IP Address
#Adjust the IP Address to match the public IP Address of your Ubuntu VM.
http://52.188.16.42/
```

If all went as planned, your connection to the VM’s Apache Web service will be established and you will be prompted with the Apache2 Ubuntu Default webpage!

![Result of successful HTTP connection to Ubuntu VM Apache web service](https://adamtheautomator.com/wp-content/uploads/2020/12/100_Apache_Webpage.png)

Result of successful HTTP connection to Ubuntu VM Apache web service

## Next Steps

In this tutorial, we leveraged Azure DSC to onboard and apply a simple Azure DSC configuration that installed and started the Apache web service on an Azure VM. Feel free to [_delete your Ubuntu VM_](https://adamtheautomator.com/azure-vm-delete/) and start again with the goal of completing the process on your own. Once complete, apply additional configurations using Azure DSC to other nodes in your Microsoft Azure environment.

Share this article

[Share on X](https://twitter.com/intent/tweet?url=https%3A%2F%2Fadamtheautomator.com%2Fazure-dsc%2F&text=Implementing%20Azure%20DSC%3A%20A%20Step-by-Step%20Guide)[Share on Facebook](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fadamtheautomator.com%2Fazure-dsc%2F)[Share on LinkedIn](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fadamtheautomator.com%2Fazure-dsc%2F)

## Related Posts

![](https://adamtheautomator.com/wp-content/uploads/2023/10/automating-azure-resource.jpg)

### [Automating Azure Resource Deployments in PowerShell: Part 1](/automating-azure-resource/)

Learn the many ways to get started with automating Azure resource deployments in part one of this three part series.

![](https://adamtheautomator.com/wp-content/uploads/2023/02/create-an-azure-vm.jpg)

### [Discover How to Create an Azure VM in Microsoft Azure Cloud](/create-an-azure-vm/)

Learn the many ways how to create an Azure VM in the Microsoft Azure Cloud and move your resources and processes into the cloud!

![](https://adamtheautomator.com/wp-content/uploads/2022/11/azure-kubernetes-service.jpg)

### [Getting Started with the Azure Kubernetes Service (AKS)](/azure-kubernetes-service/)

Learn how to leverage Microsoft Azure Kubernetes Service (AKS) and take your DevOps infrastructure to the next level!

## Categories

*   [IT Ops](/category/it-ops/)
*   [Cloud](/category/cloud/)
*   [DevOps](/category/devops/)
*   [Home Ops](/category/home-ops/)
*   [Information Security](/category/infosec/)
*   [Software Development](/category/software-development/)

## Site

*   [Home](/)
*   [Tutorials](/tutorials/)
*   [Instructors](/author/)
*   [Advertising](/advertising/)
*   [Recommended Resources](/resources/)
*   [About Adam](/about-adam/)

Copyright 2026© ATA Learning | [Privacy Policy](/privacy/)