¿Cómo conectar Azure Data Factory con un servidor SFTP, guardando las credenciales en Azure Key Vault?


conectar azure data factory

 

Es habitual que para alimentar nuestro sistema recojamos datos de múltiples fuentes, algunas de ellas sistemas más antiguos de los que debemos traernos los ficheros con los datos necesarios.

Azure Data Factory tiene conectores SFTP para facilitarnos esta tarea, y si los vais a usar con un nombre de usuario y contraseña, no vais a tener ningún problema, pero lo habitual es que debamos conectarnos de manera segura usando un certificado, que se ha dado de alta previamente en el servidor.

Pues bien, resulta que esta tarea no es compleja, pero no hay un lugar donde se explique cómo hacerlo de manera sencilla, y es por ello que vamos a daros los pasos para realizar dicha tarea.

0- Prerrequisitos:

azure data factory prerrequisitosEste punto sólo debéis seguirlo para hacer pruebas, puesto que en otras condiciones vuestro entorno ya debe disponer de Data Factory, de un Key Vault. Si este fuera el caso, saltad directamente al punto 1.

0.1- Crear una VM

Vamos a crear una VM en Azure para hacer de servidor SFTP. Como no va a tener más funciones, cogeremos el modelo más básio:

Basic A0 (1 vcpus, 0.75 GiB memory)

0.2- Crear un Data Factory

Para realizar este tutorial, damos por hecho que existe un Data Factory creado. ¿No existe? No es problema, puede crearse con el siguiente comando vía Powershell (o lo puedes crear desde el portal de Azure):

Set-AzDataFactoryV2 -ResourceGroupName <grupo> -Location <ubicación> -Name <nombre_data_factory>

0.3 Crear un Key Vault

Necesitaremos un lugar para guardar nuestras credenciales, las que usaremos para conectarnos al SFTP. Ese sitio es el Key Vault. Si no tenéis uno creado, podéis crearlo usando el portal web de Azure, o vía Powershell ejecutando el siguiente comando:

New-AzKeyVault -Name <nombre> -ResourceGroupName <grupo> -Location <ubicación>

 

1- Generación de la clave y activación en el servidor SFTP

azure data factory En este paso crearemos una pareja de claves, para poder usarlas como credenciales de nuestro servidor SFTP. Si nos dan el certificado, nos saltamos este paso, ya que entendemos que está generado e instalado en el servidor.

1.1- Generar un certificado:

Para generar la pareja de claves en una máquina tipo Linux, podemos ejecutar el siguiente comando:

ssh-keygen -t rsa

Dejamos todas las opciones por defecto. Esto creará en nuestro directorio $HOME/.ssh los ficheros id_rsa y id rsa.pub, que son la claves privada y pública generadas.

1.2- Damos de alta el certificado en la máquina SFTP

Ahora vamos a dar de alta la autenticación mediante dicha pareja de claves en el servidor SFTP. Para ello tenemos dos opciones, desde la VM que generamos el certificado, podemos usar el comando ssh-copy-id (indicando el usuario que asociamos y el host del sftp) o incluir directamente el contenido público en authorized_keys.

Opción A - Usar ssh-copy-id:

Podemos lanzar el siguiente comando:

ssh-copy-id -i ~/.ssh/id_rsa.pub user@localhost 

Sustituyendo los valores necesarios, que son:

  • user → El usuario que vamos a asociar al certificado
  • localhost → La máquina a la que vamos a copiar el certificado (en este caso la VM que generó los certificados y el servidor SFTP son el mismo)
  • ~/.ssh/id_rsa.pub → La clave pública generada, que vamos a copiar.
Opción B - añadir manualmente la clave:

Nos copiamos la clave pública al home del usuario, en el servidor SFTP que vamos a autorizar, y lo añadimos a su fichero de claves autorizadas con este comando:

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

1.3 Confirmo que puedo conectarme mediante certificado

Realizo una conexión SSH desde la máquina en la que generé el certificad hacia la máquina que lo copié.

1.4 Me copio la clave privada a mi PC

Nos copiamos el fichero id_rsa, que es el que usaremos para autenticarnos contra el servidor SFTP.

 

2- Damos de alta un secreto con la clave privada:

alta un secreto con la clave privadaDar de alta el certificado en el Key Vault no es nada intuitivo. En primer lugar, tenemos que darlo de alta como secreto, y además, no podemos incluir el contenido tal cual, tenemos que codificarlo en Base64.

En el siguiente script, cogemos el contenido del fichero de la clave, lo codificamos en Base64, lo convertimos en SecureString, y finalmente lo añadimos como secreto a nuestro Key Vault.

$texto = (Get-Content .\<fichero_privado> -Raw)
$Bytes = [System.Text.Encoding]::UTF8.GetBytes($texto)
$EncodedText =[Convert]::ToBase64String($Bytes)
$secret = ConvertTo-SecureString -String $EncodedText -AsPlainText -Force
Set-AzKeyVaultSecret -VaultName <vault_name> -name <nombre_secreto> -SecretValue $secret 

NOTA: $Bytes = [System.Text.Encoding]::Unicode.GetBytes($texto) también debería funcionar

3- Dar permisos al Data Factory de acceso al Key Vault para obtener secretos:

3.1- Obtenemos la Managed identity creada para el Data Factory :

Al crear un Data Factory se crea una Managed Identity automáticamente. Esa identidad es lo quesa el Data Factory para acceder al Key Vault para leer secretos. Necesitamos darle permisos de acceso a dicho Key Vault para obtener secretos.

Este acceso es necesario ya que el certificado que usaremos para conectarnos al SFTP está ahí (guardado como secreto).

Con este comando, obtendremos dicha Managed Identity, para darle los permisos posteriormente.

$PrincipalId = (Get-AzDataFactoryV2 -ResourceGroupName <grupo> -Name <nombre_data_factory>).Identity.PrincipalId
$DfPrincipal = Get-AzADServicePrincipal |where-object { $_.ID -eq $PrincipalId }

3.2- Damos permisos a dicha entidad

Ahora que tenemos la Managed Identity, vamos a darle permisos para ejecutar Get y List sobre secretos en el Key Vault (o los permisos que necesitéis).

Set-AzKeyVaultAccessPolicy -VaultName <key_vault_name> -ObjectId $DfPrincipal.Id -PermissionsToSecrets Get,List -PassThru

NOTA: Este otro comando, sería el ejemplo para dar todos los permisos.

Set-AzKeyVaultAccessPolicy -VaultName &lt;key_vault_name&gt; -ObjectId $DfPrincipal.Id -
PermissionsToKeys
Decrypt,Encrypt,UnwrapKey,WrapKey,Verify,Sign,Get,List,Update,Create,Import,Delete,Backu
p,Restore,Recover,Purge -PermissionsToSecrets
Get,List,Set,Delete,Backup,Restore,Recover,Purge -PermissionsToCertificates
Get,List,Delete,Create,Import,Update,Managecontacts,Getissuers,Listissuers,Setissuers,Deletei
ssuers,Manageissuers,Recover,Backup,Restore,Purge -PassThru

4- Damos de alta un Linked Service para acceder al Key Vault:

Este paso lo podéis hacer a través del portal de Azure, pero aquí os vamos a mostrar cómo hacerlo programáticamente a través de la consola PowerShell.

Creamos el fichero key-vault-service.json, sustituyendo los valores que debamos:

  • keyvault_service_name → Nombre con el que vamos a dar de alta el Linked Service
  • key_vault_name → Nombre del Key Vault al que nos vamos a asociar.
{
    "name": "<keyvault_service_name>",
    "type": "Microsoft.DataFactory/factories/linkedservices",
    "properties": {
        "annotations": [],
        "type": "AzureKeyVault",
        "typeProperties": {
            "baseUrl": "https://<key_vault_name>.vault.azure.net/"
        }

    }
}

Con el fichero creado, damos de alta el Linked Service:

Set-AzDataFactoryV2LinkedService 
-DataFactoryName <nombre_data_factory> 
-ResourceGroupName <grupo>
-name <keyvault_service_name> 
-File ".\key-vault-service.json"

5. Damos de alta un Linked Service de tipo SFTP que se conecta vía SSH usando la clave almacenada en un secreto del Key Vault:

Para poder conectarnos al SFTP, debemos dar de alta un servicio asociado. Aquí mostramos cómo hacerlo programáticamente.

Creamos el fichero sftp-service.json, sustituyendo los valores necesarios:

Set-AzDataFactoryV2LinkedService -DataFactoryName <nombre_data_factory> -ResourceGroupName <grupo> -name <keyvault_service_name> -File ".\key-vault-service.json"
  • sftp_service_name → Nombre del servicio que vamos a dar de alta
  • sftp_host → El host al que nos vamos a conectar
  • sftp_port → Puerto del SFTP
  • userName → Usuario con el que nos vamos a conectar
  • df_service_name → Nombre del linked service creado para acceder al key vault (punto 4)
  • nombre_secreto → Nombre del secreto que hemos creado con la clave privada que usaremos para conectarnos
{
    "name": "<sftp_service_name>",
    "properties": {
        "annotations": [],
        "type": "Sftp",
        "typeProperties": {
            "host": "<sftp_host>",
            "port": <sftp_port>,
            "skipHostKeyValidation": true,
            "authenticationType": "SshPublicKey",
            "userName": "<sftp_user>",
            "privateKeyContent": {
                "type": "AzureKeyVaultSecret",
                "store": {
                    "referenceName": "<keyvault_service_name>",
                    "type": "LinkedServiceReference"
                },
                "secretName": "<nombre_secreto>"
            }
        }
    },
    "type": "Microsoft.DataFactory/factories/linkedservices"
}

6- Conclusiones

Ahora ya podemos usar ese servicio SFTP para traer ficheros en forma de Datasets.

Como veis, no es especialmente complejo realizar dicha acción si seguimos este documento. Esperamos que este tutorial os ahorre las horas que nosotros dedicamos a descubrir cómo hacer este proceso.

 

 

Guía de Posibilidades Profesionales en el Ecosistema de Java