Active Directory is one of the most popular domain controller / LDAP server around.
In Azure we have Azure Active Directory (AAD). Despite the name, AAD isn’t just a multi-tenant AD. It is built for the cloud.
Sometimes though, it is useful to have a traditional domain controller… in the cloud. Typically this is with legacy workloads built to work with Active Directory. But also, a very common scenario is to join an Azure VM to a domain so that users authenticate on it with the same accounts they authenticate to use the Azure Portal.
The underlying directory could even be synced with a corporate network, in which case users could log into the VMs using their corporate account. I won’t cover this here but you can read about it in a previous article for AD Connect part.
The straightforward option is to build an Active Directory cluster on Azure VMs. This will work but requires the maintenance of those 2 VMs.
An easier option is AAD Domain Services (AADDS). AADDS exposes an AAD tenant as a managed domain service. It does it by provisioning some variant of Active Directory managed cluster, i.e. we do not see or care about the underlying VMs.
The cluster is synchronized one-way (from AAD to AADDS). For this reason, AAD is read only through its LDAP interface, e.g. we can’t reset a password using LDAP.
The Azure documentation walks us through such an integration with classic (ASM) VMs. Since ARM has been around for more than a year, I recommend to always go with ARM VMs. This article aims at showing how to do this.
I’ll heavily leveraged the existing documentation and detail only what differs from the official documentation.
Also, keep in mind this article is written in January 2017. Azure AD will transition to ARM in the future and will likely render this article obsolete.
The main challenge we face is that AAD is an ASM service and AAD Domain Service are exposed within an ASM Virtual Network (VNET), which is incompatible with our ARM VM.
Thankfully, we now have Virtual Network peering allowing us to peer an ASM and an ARM VNET together so they can act as if they were one.
As with all VNET peering, the two VNETs must be of mutually exclusive IP addresses space.
I created two VNETs in the portal (https://portal.azure.com). I recommend creating them in the new portal explicitly, this way even the classic one will be part of the desired resource group.
The classic one has 10.0.0.0/24 address range while the ARM one has 10.1.0.0/24.
The peering can be done from the portal too. In the Virtual Network pane (say the ARM one), select Peerings:
We should see an empty list here, so let’s click Add.
We need to give the peering a name. Let’s type PeeringToDomainServices.
We then select Classic in the Peer details since we want to peer with a classic VNET.
Finally, we’ll click on Choose a Virtual Network.
From there we should see the classic VNET we created.
The online documentation is quite good for this.
Just make sure you select the classic VNET we created.
You can give a domain name that is different that the AAD domain name (i.e. *.onmicrosoft.com).
Enabling AADDS takes up to 30 minutes. Don’t hold your breath!
Joining a VM
We can create a Linux VM, put it in the ARM VNET we created, and join it to the AADDS domain now.
Again, the online documentation does a great job of walking us through the process. The documentation is written for Red Hat.
When I tried it, I used a CentOS VM and I ended up using different commands, namely the realmd command (ignoring the SAMBA part of the article).
It is fairly straightforward to enable Domain Services in AAD and well documented.
A challenge we currently have currently is to join or simply communicate from an ARM VM to AADDS. For this we need two networks, a classic (ASM) one and an ARM one, and we need to peer them together.