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.
Este 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.
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)
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>
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>
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.
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.
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.
Podemos lanzar el siguiente comando:
ssh-copy-id -i ~/.ssh/id_rsa.pub user@localhost
Sustituyendo los valores necesarios, que son:
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
Realizo una conexión SSH desde la máquina en la que generé el certificad hacia la máquina que lo copié.
Nos copiamos el fichero id_rsa, que es el que usaremos para autenticarnos contra el servidor SFTP.
Dar 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
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 }
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 <key_vault_name> -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
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:
{
"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"
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"
{
"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"
}
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.