Konfigurieren eines P2S-VPNs (Point-to-Site) unter Linux zur Verwendung mit Azure Files

  • Artikel

Sie können eine P2S-VPN-Verbindung (Point-to-Site) verwenden, um Ihre Azure-Dateifreigaben außerhalb von Azure einzubinden, ohne Daten über das offene Internet zu senden. Eine P2S-VPN-Verbindung ist eine VPN-Verbindung zwischen Azure und einem einzelnen Client. Um bei Azure Files eine P2S-VPN-Verbindung verwenden zu können, müssen Sie für jeden Client, der eine Verbindung herstellen möchte, eine P2S-VPN-Verbindung konfigurieren. Wenn Sie über viele Clients verfügen, die sich über Ihr lokales Netzwerk mit Ihren Azure-Dateifreigaben verbinden müssen, können Sie anstelle einer P2S-Verbindung für jeden Client eine S2S-VPN-Verbindung (Site-to-Site) verwenden. Weitere Informationen finden Sie unter Konfigurieren eines S2S-VPN (Site-to-Site) zur Verwendung mit Azure Files.

Es wird dringend empfohlen, vor der Lektüre des dieses Artikels den Artikel Azure Files – Überlegungen zum Netzwerkbetrieb zu lesen, der eine umfassende Erläuterung der für Azure Files verfügbaren Netzwerkoptionen enthält.

Der Artikel beschreibt die Schritte zur Konfiguration eines P2S-VPN unter Linux, um Azure-Dateifreigaben direkt lokal einzubinden.

Gilt für:

Dateifreigabetyp SMB NFS
Standard-Dateifreigaben (GPv2), LRS/ZRS Ja Nein
Standard-Dateifreigaben (GPv2), GRS/GZRS Ja Nein
Premium-Dateifreigaben (FileStorage), LRS/ZRS Ja Ja

Voraussetzungen

  • Die neueste Version der Azure CLI. Informationen zum Installieren der Azure CLI finden Sie unter Installieren der Azure PowerShell CLI im Abschnitt zu Ihrem Betriebssystem. Wenn Sie es vorziehen, das Azure PowerShell-Modul unter Linux zu verwenden, können Sie dies tun. Die nachstehenden Anweisungen sind jedoch für Azure CLI vorgesehen.

  • Eine Azure-Dateifreigabe, die Sie lokal einbinden können. Azure-Dateifreigaben werden in Speicherkonten bereitgestellt. Hierbei handelt es sich um Verwaltungskonstrukte, die einen gemeinsam genutzten Pool mit Speicherplatz darstellen, in dem Sie mehrere Dateifreigaben sowie weitere Speicherressourcen wie Blobcontainer oder Warteschlangen bereitstellen können. Weitere Informationen zum Bereitstellen von Azure-Dateifreigaben und Speicherkonten finden Sie unter Erstellen einer Azure-Dateifreigabe.

  • Ein privater Endpunkt für das Speicherkonto mit der Azure-Dateifreigabe, die Sie lokal bereitstellen möchten. Informationen zum Erstellen eines privaten Endpunkts finden Sie unter Konfigurieren von Azure Files-Netzwerkendpunkten.

Installieren der erforderlichen Software

Das Azure-Gateway für virtuelle Netzwerke kann VPN-Verbindungen über verschiedene VPN-Protokolle bereitstellen, darunter z. B. IPsec und OpenVPN. Dieser Artikel zeigt die Verwendung von IPsec und verwendet das strongSwan-Paket, um die Unterstützung unter Linux zu gewährleisten.

Verifiziert mit Ubuntu 18.10.

sudo apt update
sudo apt install strongswan strongswan-pki libstrongswan-extra-plugins curl libxml2-utils cifs-utils unzip

INSTALL_DIR="/etc/"

Wenn die Installation fehlschlägt oder Sie einen Fehler erhalten (wie z. B. EAP_IDENTITY wird nicht unterstützt, EAP_NAK wird gesendet), müssen Sie möglicherweise zusätzliche Plug-Ins installieren:

sudo apt install -y libcharon-extra-plugins

Bereitstellen eines virtuellen Netzwerks

Um von einer lokalen Umgebung aus über ein P2S-VPN auf Ihre Azure-Dateifreigabe und andere Azure-Ressourcen zuzugreifen, müssen Sie ein virtuelles Netzwerk (VNET) erstellen. Die automatisch erstellte P2S-VPN-Verbindung ist eine Brücke zwischen Ihrem lokalen Linux-Computer und diesem virtuellen Azure-Netzwerk.

Das folgende Skript erstellt ein virtuelles Azure-Netzwerk mit drei Subnetzen: ein Subnetz für den Dienstendpunkt Ihres Speicherkontos, ein Subnetz für den privaten Endpunkt Ihres Speicherkontos (dieser wird für den Zugriff auf das lokale Speicherkonto ohne benutzerdefiniertes Routing für die öffentliche IP-Adresse benötigt, die sich ändern kann), und ein Subnetz für das Gateway für virtuelle Netzwerke, das den VPN-Dienst bereitstellt.

Denken Sie daran, <region>, <resource-group> und <desired-vnet-name> durch die entsprechenden Werte für Ihre Umgebung zu ersetzen.

REGION="<region>"
RESOURCE_GROUP_NAME="<resource-group>"
VIRTUAL_NETWORK_NAME="<desired-vnet-name>"

VIRTUAL_NETWORK=$(az network vnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $VIRTUAL_NETWORK_NAME \
    --location $REGION \
    --address-prefixes "192.168.0.0/16" \
    --query "newVNet.id" | tr -d '"')

SERVICE_ENDPOINT_SUBNET=$(az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --vnet-name $VIRTUAL_NETWORK_NAME \
    --name "ServiceEndpointSubnet" \
    --address-prefixes "192.168.0.0/24" \
    --service-endpoints "Microsoft.Storage" \
    --query "id" | tr -d '"')

PRIVATE_ENDPOINT_SUBNET=$(az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --vnet-name $VIRTUAL_NETWORK_NAME \
    --name "PrivateEndpointSubnet" \
    --address-prefixes "192.168.1.0/24" \
    --query "id" | tr -d '"')

GATEWAY_SUBNET=$(az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --vnet-name $VIRTUAL_NETWORK_NAME \
    --name "GatewaySubnet" \
    --address-prefixes "192.168.2.0/24" \
    --query "id" | tr -d '"')

Erstellen von Zertifikaten für die VPN-Authentifizierung

Damit VPN-Verbindungen von Ihren lokalen Linux-Computern authentifiziert werden können, um auf Ihr virtuelles Netzwerk zuzugreifen, müssen Sie zwei Zertifikate erstellen:

  • Ein Stammzertifikat, das dem Gateway des virtuellen Computers bereitgestellt wird
  • Ein Clientzertifikat, das mit dem Stammzertifikat signiert wird

Das folgende Skript erstellt die erforderlichen Zertifikate.

ROOT_CERT_NAME="P2SRootCert"
USERNAME="client"
PASSWORD="1234"

mkdir temp
cd temp

sudo ipsec pki --gen --outform pem > rootKey.pem
sudo ipsec pki --self --in rootKey.pem --dn "CN=$ROOT_CERT_NAME" --ca --outform pem > rootCert.pem

ROOT_CERTIFICATE=$(openssl x509 -in rootCert.pem -outform der | base64 -w0 ; echo)

sudo ipsec pki --gen --size 4096 --outform pem > "clientKey.pem"
sudo ipsec pki --pub --in "clientKey.pem" | \
    sudo ipsec pki \
        --issue \
        --cacert rootCert.pem \
        --cakey rootKey.pem \
        --dn "CN=$USERNAME" \
        --san $USERNAME \
        --flag clientAuth \
        --outform pem > "clientCert.pem"

openssl pkcs12 -in "clientCert.pem" -inkey "clientKey.pem" -certfile rootCert.pem -export -out "client.p12" -password "pass:$PASSWORD"

Bereitstellen eines Gateways für virtuelle Netzwerke

Das Azure-Gateway für virtuelle Netzwerke ist der Dienst, mit dem sich Ihre lokalen Linux-Computer verbinden. Die Bereitstellung dieses Diensts erfordert zwei grundlegende Komponenten:

  • Eine öffentliche IP-Adresse, die das Gateway bei Ihren Clients identifiziert, und zwar unabhängig von ihrem Standort
  • Das zuvor erstellte Stammzertifikat, das zum Authentifizieren Ihrer Clients verwendet wird

Denken Sie daran, <desired-vpn-name-here> durch den Namen zu ersetzen, den Sie für diese Ressourcen verwenden möchten.

Hinweis

Die Bereitstellung eines Azure-Gateways für virtuelle Netzwerke kann bis zu 45 Minuten dauern. Während der Bereitstellung dieser Ressource blockiert dieses Bash-Skript den Abschluss der Bereitstellung.

P2S IKEv2-/OpenVPN-Verbindungen werden für die SKU Basic nicht unterstützt. In diesem Skript wird die SKU VpnGw1 für das Gateway für virtuelle Netzwerke verwendet.

VPN_NAME="<desired-vpn-name-here>"
PUBLIC_IP_ADDR_NAME="$VPN_NAME-PublicIP"

PUBLIC_IP_ADDR=$(az network public-ip create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $PUBLIC_IP_ADDR_NAME \
    --location $REGION \
    --sku "Basic" \
    --allocation-method "Dynamic" \
    --query "publicIp.id" | tr -d '"')

az network vnet-gateway create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $VPN_NAME \
    --vnet $VIRTUAL_NETWORK_NAME \
    --public-ip-addresses $PUBLIC_IP_ADDR \
    --location $REGION \
    --sku "VpnGw1" \
    --gateway-typ "Vpn" \
    --vpn-type "RouteBased" \
    --address-prefixes "172.16.201.0/24" \
    --client-protocol "IkeV2" > /dev/null

az network vnet-gateway root-cert create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name $VPN_NAME \
    --name $ROOT_CERT_NAME \
    --public-cert-data $ROOT_CERTIFICATE \
    --output none

Konfigurieren des VPN-Clients

Das Azure-Gateway für virtuelle Netzwerke erstellt ein herunterladbares Paket mit Konfigurationsdateien, die für die Initialisierung der VPN-Verbindung auf Ihrem lokalen Linux-Computer erforderlich sind. Das folgende Skript platziert die von Ihnen erstellten Zertifikate am richtigen Standort und konfiguriert die ipsec.conf-Datei mit den korrekten Werten aus der Konfigurationsdatei im heruntergeladenen Paket.

VPN_CLIENT=$(az network vnet-gateway vpn-client generate \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $VPN_NAME \
    --authentication-method EAPTLS | tr -d '"')

curl $VPN_CLIENT --output vpnClient.zip
unzip vpnClient.zip

VPN_SERVER=$(xmllint --xpath "string(/VpnProfile/VpnServer)" Generic/VpnSettings.xml)
VPN_TYPE=$(xmllint --xpath "string(/VpnProfile/VpnType)" Generic/VpnSettings.xml | tr '[:upper:]' '[:lower:]')
ROUTES=$(xmllint --xpath "string(/VpnProfile/Routes)" Generic/VpnSettings.xml)

sudo cp "${INSTALL_DIR}ipsec.conf" "${INSTALL_DIR}ipsec.conf.backup"
sudo cp "Generic/VpnServerRoot.cer_0" "${INSTALL_DIR}ipsec.d/cacerts"
sudo cp "${USERNAME}.p12" "${INSTALL_DIR}ipsec.d/private" 

sudo tee -a "${installDir}ipsec.conf" <<EOF
conn $VIRTUAL_NETWORK_NAME
    keyexchange=$VPN_TYPE
    type=tunnel
    leftfirewall=yes
    left=%any
    leftauth=eap-tls
    leftid=%client
    right=$vpnServer
    rightid=%$vpnServer
    rightsubnet=$routes
    leftsourceip=%config
    auto=add
EOF

echo ": P12 client.p12 '$PASSWORD'" | sudo tee -a "${INSTALL_DIR}ipsec.secrets" > /dev/null

sudo ipsec restart
sudo ipsec up $VIRTUAL_NETWORK_NAME

Einbinden einer Azure-Dateifreigabe

Nun, da Sie Ihr P2S-VPN eingerichtet haben, können Sie Ihre Azure-Dateifreigabe einbinden. Weitere Informationen finden Sie unter Einbinden von SMB-Dateifreigaben in Linux oder Einbinden von NFS-Dateifreigaben in Linux.

Weitere Informationen