Years ago when I first started working with Azure, I was very excited about the release of Azure Files because it would allow migrating traditional Windows file servers to the cloud without having an IaaS Windows server providing the service. What I quickly realized was that it did not support the use of NTFS permissions and therefore was not a possible replacement. Fast forward to a few years later, the support for traditional NTFS permissions with on-premise Active Directory is finally available. I’ve been meaning to write a blog post to demonstrate the configuration so this post serves as a continuation to my previous post on how we can leverage Azure Files to replace traditional Windows Server file services.
Configuring and accessing Microsoft Azure Files
http://terenceluk.blogspot.com/2021/03/configuring-and-accessing-azure-files.html
I won’t go into too much detail about how the integration works as the information can be found in the following Microsoft documentation:
Overview - on-premises Active Directory Domain Services authentication over SMB for Azure file shares
https://docs.microsoft.com/en-us/azure/storage/files/storage-files-identity-auth-active-directory-enable
What I will do is highlight the items we need to configure it.
Topology
The environment I will be working with will be the following simple topology where an on-premise network is connected to Azure East US through a site-to-site VPN and an Azure Files configured:
Prerequisites
The following are the prerequisites for enabling AD DS authentication for Azure file shares:
- The on-premise Active Directory Domain Services will need to be synced into Azure AD with Azure AD Connect
- The identities that will be used for accessing the Azure Files need to be synced to Azure AD if filtering is applied
- The endpoint accessing the file share in Azure Files need to be able to traverse over via port 445
- A storage account name that will be less than 15 characters as that is the limit for the on-premise Active Directory SamAccountName
Step #1 – Create the Azure Storage Account and Azure File share
Begin by creating a new storage account with a name that has less than 15 characters:
With the storage account successfully created, open the new storage account and navigate to the File shares menu option:
Click on the + File share button to create a new file share:
Configure the new file share with the settings required.
I won’t go into the details of the Tiers but will provide this reference link for more information: https://docs.microsoft.com/en-us/azure/storage/files/storage-files-planning?WT.mc_id=Portal-Microsoft_Azure_FileStorage#storage-tiers
Complete creating the file share by clicking on the Create button.
With the test File share created, click to open it:
You can directly upload files into the file share, modify the tier, configure various operations and retrieve information pertaining to the file share.
Azure Storage Explorer can also be used to manage the file share.
You may notice that clicking into the Access Control (IAM) menu option will display the following:
Identity-based authentication (Active Directory) for Azure file shares
To give individual accounts access to the file share (Kerberos), enable identity-based authentication for the storage account. Learn more
This is where you would configure the Share permissions for Active Directory account access and will be configured in the following steps.
Step #2 – Enable AD DS authentication on the storage account
How Azure Files and on-premise authorization works
Unlike traditional Windows Servers, you can’t join an Azure storage account to an on-premise Active Directory so the way in which this is achieved is by registering the storage account with AD DS by creating an account representing it in AD DS. The account that will be created in the on-premise AD can be a user account or a computer account and if you are familiar with on-premise AD, you’ll immediately recognize that both of these accounts have passwords. Failure to update the password will cause authentication to Azure Files to fail.
Computer accounts – these accounts have a default password expiration age of 30 days
User accounts – these accounts have password expiration age set based on the password policy applied
The easy way to get around password expiration is to use a user account and set the password to never expire but doing so will likely get any administrator in trouble. The better method is to use Update-AzStorageAccountADObjectPassword cmdlet (https://docs.microsoft.com/en-us/azure/storage/files/storage-files-identity-ad-ds-update-password) to manually update the account’s password before it expires. There are several ways to automate this with either something as simple as a Windows task scheduler task or an enterprise management application to run it on a schedule.
Using AzFilesHybrid to create the on-premise account representing Azure Files
Proceed to download the latest AzFilesHybrid PowerShell module at the following URL: https://github.com/Azure-Samples/azure-files-samples/releases
Unpacking the ZIP file will provide the following 3 files:
- AzFilesHybrid.psd1
- AzFilesHybrid.psm1
- CopyToPSPath.ps1
Before executing the script, you’ll need to use an account with the following properties and permissions:
- Replicated to Azure AD
- Permissions to modify create a user or computer object to the on-premise Active Directory
- Storage Account Owner or Contributor permissions
The account I’ll be using is a Domain admin and Global Admin rights.
From a domain joined computer where you are logged in with the required on-premise Active Directory account, launch PowerShell or PowerShell ISE and begin by setting the execution policy to unrestricted so we can run the AzFilesHybrid PowerShell scripts:
Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser
Navigate to the directory containing the unzipped scripts and execute:
.\CopyToPSPath.ps1
Import the AzFilesHybrid module by executing:
Import-Module -Name AzFilesHybrid
Connect to the Azure tenant:
Connect-AzAccount
Set up the variables for the subscription ID, the resource group name and storage account name:
$SubscriptionId = "<SubscriptionID>"
$ResourceGroupName = "<resourceGroupName>"
$StorageAccountName = "<storageAccountName>"
As you can have more than one subscription in a tenant, select the subscription containing the resources by executing:
Select-AzSubscription -SubscriptionId $SubscriptionId
With the prerequisites executed, we can now use the Join-AzStorageAccountForAuth cmdlet to create the account in the on-premise AD that represents the storage account in Azure:
Join-AzStorageAccountForAuth `
-ResourceGroupName $ResourceGroupName `
-Name $StorageAccountName `
-DomainAccountType "<ComputerAccount or ServiceLogonAccount>" `
## You can either specify the OU name or DN of the OU
-OrganizationalUnitName "<Name of OU>" `
-OrganizationalUnitDistinguishedName "<DN of OU>"
The following is an example:
Join-AzStorageAccountForAuth `
-ResourceGroupName $ResourceGroupName `
-Name $StorageAccountName `
-DomainAccountType "ServiceLogonAccount" `
-OrganizationalUnitDistinguishedName "OU=AzureFiles,DC=contoso,DC=com"
**Note that there are backticks (the character sharing the tilde character on the keyboard) used, which is used as an word-wrap operator. It allows the command to be written in multiple lines.
-----------------------------------------------------------------------------------------------------------------------
If your storage account is longer than 15 character then you’ll get an error:
WARNING: Parameter -DomainAccountType is 'ServiceLogonAccount', which will not be supported AES256 encryption for Kerberos tickets.
Join-AzStorageAccountForAuth : Parameter -StorageAccountName 'steastusserviceendpoint' has more than 15 characters, which is not supported to be used
as the SamAccountName to create an Active Directory object for the storage account. Azure Files will be supporting AES256 encryption for Kerberos
tickets, which requires that the SamAccountName match the storage account name. Please consider using a storage account with a shorter name.
At line:1 char:1
+ Join-AzStorageAccountForAuth `
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: (:) [Write-Error], WriteErrorException
+ FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Join-AzStorageAccount
-----------------------------------------------------------------------------------------------------------------------
Successful execution of the Join-AzStorageAccountForAuth will display the following:
PS C:\AzFilesHybrid> Join-AzStorageAccountForAuth `
-ResourceGroupName $ResourceGroupName `
-Name $StorageAccountName `
-DomainAccountType "ServiceLogonAccount" `
-OrganizationalUnitDistinguishedName "OU=AzureFiles,DC=contoso,DC=com"
WARNING: Parameter -DomainAccountType is 'ServiceLogonAccount', which will not be supported AES256 encryption for Kerberos tickets.
StorageAccountName ResourceGroupName PrimaryLocation SkuName Kind AccessTier CreationTime ProvisioningState EnableHttpsTrafficOnly
------------------ ----------------- --------------- ------- ---- ---------- ------------ ----------------- ----------------------
stfsreplacement rg-prod-infraServers eastus Standard_LRS StorageV2 Hot 3/8/2021 11:30:02 AM Succeeded True
PS C:\AzFilesHybrid>
The corresponding object (in this case a user object) should also be created in the specified OU:
Notice how the password is automatically set to not expire:
We can also verify the configuration with the following PowerShell cmdlets:
Obtain the storage account and store it as a variable:
$storageAccount = Get-AzStorageAccount `
-ResourceGroupName $ResourceGroupName `
-Name $StorageAccountName
List the directory domain information of the storage account has enabled AD DS authentication for file shares
$storageAccount.AzureFilesIdentityBasedAuth.ActiveDirectoryProperties
View the directory service of the storage:
$storeageAccount.AzureFilesIdentityBasedAuth.DirectoryServiceOptions
Step #3 – Configure On-Premise AD Groups for Azure Files Access (Share Permissions)
With the AD DS authentication integration setup for the storage account, the next step is to configure the on-premise Active Directory groups that will be granted access to the Azure Files file share. Think of this step as how we would configure Share permissions on a folder so we can then proceed to configure the NTFS permissions.
There are 3 predefined RBAC roles provided by Azure that will map to the on-premise AD groups and they are as follows:
Storage File Data SMB Share Contributor – Allows for read, write, and delete access in Azure Storage file shares over SMB.
Storage File Data SMB Share Elevated Contributor – Allows for read, write, delete and modify NTFS permissions access in Azure Storage file shares over SMB.
Storage File Data SMB Share Reader – Allows for read access to Azure File Share over SMB.
The following are the mappings that I have planned:
Azure Role: Storage File Data SMB Share Contributor
On-premise AD group: AzFileShareContributor
Azure Role: Storage File Data SMB Share Elevated Contributor
On-premise AD group: AzFileShareElevContributor
Azure Role: Storage File Data SMB Share Reader
On-premise AD group: AzFileShareReader
Proceed to create the groups in the on-premise Active Directory:
Then log into the Azure portal and navigate to the storage account > File Shares then click on the file share that has been created:
From within the file share, click on Access Control (IAM) and then Add role assignments:
Configure the appropriate mapping for the 3 on-premise AD groups and the Azure roles:
Step #4 – Mount the Azure Files file share with full permissions and configure NTFS permissions
With the share permissions set, we can now configure the NTFS permissions on the file share. There isn’t a way to perform this from within the Azure portal so we will need to mount an Azure file share to a VM joined to the on-premise Active Directory.
The UNC path for accessing the Azure Files share would be as follows:
\\<storageAccountName>.file.core.windows.net\<shareName> <storageAccountKey> /user:Azure\<storageAccountName>
You can use the net use <driveLetter>: command to mount the drive as such:
net use z: \\<storageAccountName>.file.core.windows.net\<shareName> <storageAccountKey> /user:Azure\<storageAccountName>
net use z: \\stfsreplacement.file.core.windows.net\test N2PrIm73/xHNPxe7BoVyNHBdjU3HBPpQg33Z+PeKmjy8nxUMSeOG4Azfnknyn+up2pQpOinUJ/FWl9ceeGz/bQ== /user:Azure\stfsreplacement
Note that the storage account key can be obtained here:
Or as an alternative, you can also retrieve a full PowerShell cmdlet to map the drive by using the Connect button for the file share:
With the file share mapped as a drive, we can now assign the appropriate NTFS permissions for the groups we created earlier:
Azure Role: Storage File Data SMB Share Contributor
On-premise AD group: AzFileShareContributor
Permissions:
- Modify
- Read & execute
- List folder contents
- Read
Azure Role: Storage File Data SMB Share Elevated Contributor
On-premise AD group: AzFileShareElevContributor
Permissions:
- Full control
- Modify
- Read & execute
- List folder contents
- Read
Azure Role: Storage File Data SMB Share Reader
On-premise AD group: AzFileShareReader
Permissions:
- Read & execute
- List folder contents
- Read
Step #5 – Mount the Azure Files file share as an on-premise Active Directory User
Now that the share and NTFS permissions have been set, we can proceed to mount the share as users who are placed into one of the 3 groups to test.
Step #6 – Update the password of the storage account identity in the on-premise Active Directory DS
The last action is how we would change/update the password on the account object representing storage account to enable Kerberos authentication. The following is a snippet from the Microsoft documentation: https://docs.microsoft.com/en-us/azure/storage/files/storage-files-identity-ad-ds-update-password
If you registered the Active Directory Domain Services (AD DS) identity/account that represents your storage account in an organizational unit or domain that enforces password expiration time, you must change the password before the maximum password age. Your organization may run automated cleanup scripts that delete accounts once their password expires. Because of this, if you do not change your password before it expires, your account could be deleted, which will cause you to lose access to your Azure file shares.
To trigger password rotation, you can run the Update-AzStorageAccountADObjectPassword command from the AzFilesHybrid module. This command must be run in an on-premises AD DS-joined environment using a hybrid user with owner permission to the storage account and AD DS permissions to change the password of the identity representing the storage account. The command performs actions similar to storage account key rotation. Specifically, it gets the second Kerberos key of the storage account, and uses it to update the password of the registered account in AD DS. Then, it regenerates the target Kerberos key of the storage account, and updates the password of the registered account in AD DS. You must run this command in an on-premises AD DS-joined environment.
The syntax for the Update-AzStorageAdccountADObjectPassword cmdlet to perform this will look as follows:
Update-AzStorageAccountADObjectPassword `
-RotateToKerbKey kerb2 `
-ResourceGroupName "<resourceGroupName>" `
-StorageAccountName "<storageAccountName>"
If you are continuing the configuration from the beginning of this blog post then the resource group and storage accounts are already stored in a variable so you can just call them as such:
Update-AzStorageAccountADObjectPassword `
-RotateToKerbKey kerb2 `
-ResourceGroupName $ResourceGroupName `
-StorageAccountName $StorageAccountName
Hope this helps anyone looking for a step by step demonstration on how to setup Azure Files for SMB accessing using on-premise AD NTFS permissions.
