Configura gli endpoint di rete per le condivisioni file di Azure

Nella pagina Risorse, seleziona Microsoft. Storage/storageAccount dal menu a tendina per Tipo di risorsa. Per Risorsa, seleziona l'account di archiviazione specifico a cui vuoi connetterti. Per la sotto-risorsa Target, seleziona file. Selezionare Avanti: Rete virtuale.

Nella pagina Risorse, seleziona Microsoft. FileShares/fileShares dal menu a tendina per il tipo di risorsa. Per Risorsa, seleziona la condivisione file specifica a cui vuoi collegarti. La sotto-risorsa di destinazione viene popolata automaticamente con FileShare. Selezionare Avanti: Rete virtuale.

Ottieni un riferimento all'account di archiviazione:

$storageAccountResourceGroupName = "<storage-account-resource-group-name>"
$storageAccountName = "<storage-account-name>"

$storageAccountParams = @{
    ResourceGroupName = $storageAccountResourceGroupName
    Name = $storageAccountName
    ErrorAction = "SilentlyContinue"
}
$storageAccount = Get-AzStorageAccount @storageAccountParams

if ($null -eq $storageAccount) {
    $errorMessage = "Storage account $storageAccountName not found "
    $errorMessage += "in resource group $storageAccountResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Set common variables for private endpoint creation
$resourceGroupName = $storageAccountResourceGroupName
$privateLinkResourceId = $storageAccount.Id
$groupId = "file"
$dnsRecordName = $storageAccountName

Ottieni un riferimento alla condivisione file:

$fileShareResourceGroupName = "<resource-group-name>"
$fileShareName = "<file-share-name>"

$fileShareParams = @{
    ResourceGroupName = $fileShareResourceGroupName
    ResourceName = $fileShareName
    ErrorAction = "SilentlyContinue"
}
$fileShare = Get-AzFileShare @fileShareParams

if ($null -eq $fileShare) {
    $errorMessage = "File share $fileShareName not found "
    $errorMessage += "in resource group $fileShareResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Extract hostName and hostNamePrefix for DNS record
$hostName = $fileShare.HostName
$hostNamePrefix = $hostName.Split('.')[0]

# Set common variables for private endpoint creation
$resourceGroupName = $fileShareResourceGroupName
$privateLinkResourceId = $fileShare.Id
$groupId = "FileShare"
$dnsRecordName = $hostNamePrefix

Ottieni un riferimento all'account di archiviazione:

storageAccountResourceGroupName="<storage-account-resource-group-name>"
storageAccountName="<storage-account-name>"

# Get storage account ID
privateLinkResourceId=$(az storage account show \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --query "id" --output tsv)

# Set common variables for private endpoint creation
resourceGroupName=$storageAccountResourceGroupName
groupId="file"
dnsRecordName=$storageAccountName

Ottieni un riferimento alla condivisione file:

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"

# Get the file share resource ID and host name
privateLinkResourceId=$(az fileshare show \
    --resource-group $fileShareResourceGroupName \
    --name $fileShareName \
    --query "id" --output tsv)

hostName=$(az fileshare show \
    --resource-group $fileShareResourceGroupName \
    --name $fileShareName \
    --query "properties.hostName" --output tsv)

hostNamePrefix=$(echo $hostName | cut -d'.' -f1)

# Set common variables for private endpoint creation
resourceGroupName=$fileShareResourceGroupName
groupId="FileShare"
dnsRecordName=$hostNamePrefix

Sostituisci <storage-account-name> con il nome appropriato dell'account di archiviazione:

nslookup <storage-account-name>.file.core.windows.net

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale (output visualizzato per Windows).

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    storageaccount.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  storageaccount.file.core.windows.net

Usa il nome host della condivisione di file. Nella pagina Panoramica della condivisione file, seleziona Visualizzazione JSON. In properties, copiare il valore di hostName. Il formato è simile a fs-xxxxxxxxxxxxxxxxx.xx.file.storage.azure.net.

nslookup <file-share-host-name>

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale (output visualizzato per Windows).

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    <hostNamePrefix>.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  <hostNamePrefix>.<zone>.file.storage.azure.net

$storageAccountHostName = [System.Uri]::new($storageAccount.PrimaryEndpoints.File) |
    Select-Object -ExpandProperty Host

$storageAccountHostName

Su un client nella rete virtuale, esegui il seguente comando. Sostituisci <host-name> con il nome host del passaggio precedente.

Resolve-DnsName -Name "<host-name>"

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale.

Name                             Type   TTL   Section    NameHost
----                             ----   ---   -------    --------
storageaccount.file.core.windows CNAME  60    Answer     storageaccount.privatelink.file.core.windows.net
.net

Name       : storageaccount.privatelink.file.core.windows.net
QueryType  : A
TTL        : 600
Section    : Answer
IP4Address : 192.168.0.5

$fileShare.HostName

Su un client nella rete virtuale, esegui il seguente comando. Sostituisci <host-name> con il nome host del passaggio precedente.

Resolve-DnsName -Name "<host-name>"

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale.

Name                                       Type   TTL   Section    NameHost
----                                       ----   ---   -------    --------
<hostNamePrefix>.<zone>.file.storage.azur  CNAME  60    Answer     <hostNamePrefix>.privatelink.file.core.windows.net
e.net

Name       : <hostNamePrefix>.privatelink.file.core.windows.net
QueryType  : A
TTL        : 600
Section    : Answer
IP4Address : 192.168.0.5

httpEndpoint=$(az storage account show \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --query "primaryEndpoints.file" --output tsv)

hostName=${httpEndpoint#https://}
hostName=${hostName%/}
echo $hostName

Su un client nella rete virtuale, esegui il seguente comando. Sostituisci <host-name> con il nome host del passaggio precedente.

nslookup <host-name>

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale.

Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
storageaccount.file.core.windows.net      canonical name = storageaccount.privatelink.file.core.windows.net.
Name:   storageaccount.privatelink.file.core.windows.net
Address: 192.168.0.5

hostName=$(az fileshare show \
    --resource-group $fileShareResourceGroupName \
    --name $fileShareName \
    --query "properties.hostName" --output tsv)

echo $hostName

Su un client nella rete virtuale, esegui il seguente comando. Sostituisci <host-name> con il nome host del passaggio precedente.

nslookup <host-name>

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale.

Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
<hostNamePrefix>.<zone>.file.storage.azure.net      canonical name = <hostNamePrefix>.privatelink.file.core.windows.net.
Name:   <hostNamePrefix>.privatelink.file.core.windows.net
Address: 192.168.0.5

Per disabilitare l'accesso pubblico alla rete per le classiche condivisioni file, segui questi passaggi:

1. Vai all'account di archiviazione dove vuoi limitare tutti gli accessi in entrata all'endpoint pubblico.
2. Dal menu del servizio, in Sicurezza e rete, selezionare Rete.
3. In Accesso alla rete pubblica selezionare Gestisci.
4. Seleziona Disabilita, poi seleziona Procedi.
5. Seleziona Salva.

Passare alla condivisione file in cui si vuole disabilitare l'accesso pubblico. Nel menu del servizio, in Impostazioni, selezionare Rete. Per l'accesso agli endpoint pubblici, seleziona Disabilitato, poi seleziona Salva.

Per le condivisioni file classiche, imposta -PublicNetworkAccess su Disabled sull'account di archiviazione.

# Use the storage account variables from the beginning of this article.
$publicNetworkAccessParams = @{
    ResourceGroupName = $storageAccountResourceGroupName
    Name = $storageAccountName
    PublicNetworkAccess = "Disabled"
    ErrorAction = "Stop"
}
Set-AzStorageAccount @publicNetworkAccessParams | Out-Null

Imposta -PublicNetworkAccess su Disabled nella condivisione di file.

$fileShareResourceGroupName = "<resource-group-name>"
$fileShareName = "<file-share-name>"

$publicNetworkAccessParams = @{
    ResourceGroupName = $fileShareResourceGroupName
    ResourceName = $fileShareName
    PublicNetworkAccess = "Disabled"
}
Update-AzFileShare @publicNetworkAccessParams

Per le condivisioni file classiche, imposta --public-network-access su Disabled sull'account di archiviazione.

# This assumes $storageAccountResourceGroupName and $storageAccountName
# are still defined from the beginning of this article.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --public-network-access Disabled \
    --output none

Imposta --public-network-access su Disabled nella condivisione di file.

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"

az fileshare update \
    --name $fileShareName \
    --resource-group $fileShareResourceGroupName \
    --public-network-access Disabled

Per le condivisioni file classiche, segui questi passaggi per limitare l'endpoint pubblico a reti specifiche.

1. Vai all'account di archiviazione dove vuoi limitare l'endpoint pubblico a reti specifiche.
2. Dal menu del servizio, in Sicurezza e rete, selezionare Rete.
3. In Accesso alla rete pubblica selezionare Gestisci.
4. In Ambito di accesso alla rete pubblica, selezionare Abilitato per le reti selezionate, quindi selezionare Salva.
5. In Impostazioni risorse: Reti virtuali, indirizzi IP ed eccezioni, seleziona Gestisci.
6. Sotto Reti Virtuali, seleziona Aggiungi una rete virtuale>Aggiungi rete virtuale esistente. Seleziona la rete virtuale e le sottoreti. Se una subnet non ha l' Microsoft.Storage endpoint del servizio, seleziona Abilita e attendi che l'operazione finisca. Quindi, selezionare Aggiungi.
7. Per l'accesso SMB o FileREST, sotto Indirizzi IPv4, inserisci gli indirizzi IP pubblici o gli intervalli che vuoi consentire. Le regole relative agli indirizzi IP non consentono l'accesso tramite NFS.
8. Se un'integrazione di un servizio richiede l'accesso a un servizio affidabile, in Eccezioni selezionare Consenti ai servizi Microsoft attendibili di accedere a questa risorsa.
9. Seleziona Salva.

Per Microsoft.FileShares, segui questi passaggi per limitare l'endpoint pubblico a reti specifiche.

1. Passare alla condivisione file in cui si vuole limitare l'accesso pubblico.
2. Nel menu del servizio, in Impostazioni, selezionare Rete.
3. Assicurati che l'accesso agli endpoint pubblici sia impostato su Abilitato.
4. Sotto restrizioni di endpoint pubblico, seleziona Aggiungi una rete virtuale. Seleziona la rete virtuale e le sottoreti. Se una subnet non ha l' Microsoft.Storage endpoint del servizio, seleziona Abilita e attendi che l'operazione finisca. Quindi, selezionare Aggiungi.
5. Seleziona Salva.

Per le condivisioni file classiche, limitare l'accesso all'endpoint pubblico dell'account di archiviazione a reti virtuali specifiche usando gli endpoint di servizio. Prima di tutto, raccogliere informazioni sull'account di archiviazione e sulla rete virtuale. Sostituire i valori segnaposto nei passaggi seguenti con i propri valori.

$storageAccountResourceGroupName = "<storage-account-resource-group>"
$storageAccountName = "<storage-account-name>"
$restrictToVirtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$restrictToVirtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"

$storageAccountParams = @{
    ResourceGroupName = $storageAccountResourceGroupName
    Name = $storageAccountName
    ErrorAction = "Stop"
}
$storageAccount = Get-AzStorageAccount @storageAccountParams

$virtualNetworkParams = @{
    ResourceGroupName = $restrictToVirtualNetworkResourceGroupName
    Name = $restrictToVirtualNetworkName
    ErrorAction = "Stop"
}
$virtualNetwork = Get-AzVirtualNetwork @virtualNetworkParams

$subnet = $virtualNetwork |
    Select-Object -ExpandProperty Subnets |
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    $errorMessage = "Subnet $subnetName not found in virtual network $restrictToVirtualNetworkName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

Per consentire il traffico dalla rete virtuale, l'infrastruttura di rete Azure deve esporre l'Microsoft.Storageendpoint del servizio alla subnet della rete virtuale. I comandi di PowerShell seguenti aggiungono l'endpoint di servizio Microsoft.Storage alla subnet, se non è già presente.

$serviceEndpoints = $subnet |
    Select-Object -ExpandProperty ServiceEndpoints |
    Select-Object -ExpandProperty Service

if ($serviceEndpoints -notcontains "Microsoft.Storage") {
    # Change the subnet object directly so the subnet keeps its delegations
    # and service endpoint policies.
    $storageEndpointParams = @{
        TypeName = "Microsoft.Azure.Commands.Network.Models.PSServiceEndpoint"
        Property = @{ Service = "Microsoft.Storage" }
    }
    $storageEndpoint = New-Object @storageEndpointParams
    $subnet.ServiceEndpoints = @($subnet.ServiceEndpoints | Where-Object { $_ }) + $storageEndpoint

    $virtualNetwork = $virtualNetwork | Set-AzVirtualNetwork -ErrorAction Stop
}

L'ultimo passo per limitare il traffico all'account di storage è creare una regola di rete virtuale e aggiungerla al set di regole di rete dell'account di storage.

$networkRuleParams = @{
    VirtualNetworkResourceId = $subnet.Id
    ErrorAction = "Stop"
}
$networkRule = $storageAccount | Add-AzStorageAccountNetworkRule @networkRuleParams

$networkRuleSetParams = @{
    DefaultAction = "Deny"
    VirtualNetworkRule = $networkRule
    WarningAction = "SilentlyContinue"
    ErrorAction = "Stop"
}
$storageAccount | Update-AzStorageAccountNetworkRuleSet @networkRuleSetParams | Out-Null

Questi comandi preservano le impostazioni di bypass esistenti. Se un'integrazione richiede l'accesso a un servizio affidabile, aggiungi -Bypass AzureServices al comando update. Il parametro sostituisce l'impostazione di bypass, quindi includi tutte le altre opzioni di bypass che il tuo carico di lavoro richiede ancora.

Per l'accesso SMB o FileREST da internet, puoi anche consentire indirizzi IP pubblici o intervalli. Le regole degli indirizzi IP non si applicano ai client nella stessa regione Azure dell'account storage. Per altre restrizioni, vedi le regole sugli indirizzi IP.

$ipAddressOrRange = "<public-ip-address-or-cidr-range>"

$ipRuleParams = @{
    ResourceGroupName = $storageAccountResourceGroupName
    Name = $storageAccountName
    IPAddressOrRange = $ipAddressOrRange
    ErrorAction = "Stop"
}
Add-AzStorageAccountNetworkRule @ipRuleParams | Out-Null

Passa gli ID delle risorse di subnet consentiti a Update-AzFileShare usando -AllowedSubnet. Le regole di rete si applicano direttamente alla condivisione file, quindi non c'è un account di archiviazione da configurare. La subnet client deve già avere l'endpoint Microsoft.Storage del servizio.

$fileShareResourceGroupName = "<resource-group-name>"
$fileShareName = "<file-share-name>"
$virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$virtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"

$virtualNetworkParams = @{
    ResourceGroupName = $virtualNetworkResourceGroupName
    Name = $virtualNetworkName
}
$subnet = Get-AzVirtualNetwork @virtualNetworkParams |
    Select-Object -ExpandProperty Subnets |
    Where-Object { $_.Name -eq $subnetName }

$allowedSubnetParams = @{
    ResourceGroupName = $fileShareResourceGroupName
    ResourceName = $fileShareName
    AllowedSubnet = @($subnet.Id)
}
Update-AzFileShare @allowedSubnetParams

Per le condivisioni file classiche, limitare l'accesso all'endpoint pubblico dell'account di archiviazione a reti virtuali specifiche usando gli endpoint di servizio. Prima di tutto, raccogliere informazioni sull'account di archiviazione e sulla rete virtuale. Sostituire i valori segnaposto nei passaggi seguenti con i propri valori.

storageAccountResourceGroupName="<storage-account-resource-group>"
storageAccountName="<storage-account-name>"
restrictToVirtualNetworkResourceGroupName="<vnet-resource-group-name>"
restrictToVirtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"

storageAccount=$(az storage account show \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --query "id" --output tsv)

virtualNetwork=$(az network vnet show \
    --resource-group $restrictToVirtualNetworkResourceGroupName \
    --name $restrictToVirtualNetworkName \
    --query "id" --output tsv)

subnet=$(az network vnet subnet show \
    --resource-group $restrictToVirtualNetworkResourceGroupName \
    --vnet-name $restrictToVirtualNetworkName \
    --name $subnetName \
    --query "id" --output tsv)

Per consentire il traffico dalla rete virtuale, l'infrastruttura di rete Azure deve esporre l'Microsoft.Storageendpoint del servizio alla subnet della rete virtuale. I seguenti comandi CLI aggiungono l'endpoint di servizio Microsoft.Storage alla subnet, se non è già incluso.

serviceEndpoints=$(az network vnet subnet show \
    --resource-group $restrictToVirtualNetworkResourceGroupName \
    --vnet-name $restrictToVirtualNetworkName \
    --name $subnetName \
    --query "serviceEndpoints[].service" \
    --output tsv)

foundStorageServiceEndpoint=false
for serviceEndpoint in $serviceEndpoints
do
    if [ $serviceEndpoint = "Microsoft.Storage" ]
    then
        foundStorageServiceEndpoint=true
    fi
done

if [ $foundStorageServiceEndpoint = false ]
then
    serviceEndpointList=""

    for serviceEndpoint in $serviceEndpoints
    do
        serviceEndpointList+=$serviceEndpoint
        serviceEndpointList+=" "
    done

    serviceEndpointList+="Microsoft.Storage"

    az network vnet subnet update \
        --ids $subnet \
        --service-endpoints $serviceEndpointList \
        --output none
fi

L'ultimo passo per limitare il traffico all'account di storage è creare una regola di rete virtuale e aggiungerla al set di regole di rete dell'account di storage.

az storage account network-rule add \
    --resource-group $storageAccountResourceGroupName \
    --account-name $storageAccountName \
    --subnet $subnet \
    --output none

az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --default-action "Deny" \
    --output none

Questi comandi preservano le impostazioni di bypass esistenti. Se un'integrazione richiede l'accesso a un servizio affidabile, aggiungi --bypass AzureServices al comando update. L'opzione sostituisce l'impostazione di bypass, quindi includi tutte le altre opzioni di bypass che il tuo carico di lavoro richiede ancora.

Per l'accesso SMB o FileREST da internet, puoi anche consentire indirizzi IP pubblici o intervalli. Le regole degli indirizzi IP non si applicano ai client nella stessa regione Azure dell'account storage. Per altre restrizioni, vedi le regole sugli indirizzi IP.

ipAddressOrRange="<public-ip-address-or-cidr-range>"

az storage account network-rule add \
    --resource-group $storageAccountResourceGroupName \
    --account-name $storageAccountName \
    --ip-address $ipAddressOrRange \
    --output none

Passa gli ID delle risorse di subnet consentiti a az fileshare update usando --allowed-subnets. Le regole di rete si applicano direttamente alla condivisione file, quindi non c'è un account di archiviazione da configurare. La subnet client deve già avere l'endpoint Microsoft.Storage del servizio.

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"
virtualNetworkResourceGroupName="<vnet-resource-group-name>"
virtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"

subnetId=$(az network vnet subnet show \
    --resource-group $virtualNetworkResourceGroupName \
    --vnet-name $virtualNetworkName \
    --name $subnetName \
    --query "id" --output tsv)

az fileshare update \
    --name $fileShareName \
    --resource-group $fileShareResourceGroupName \
    --allowed-subnets $subnetId