Hola a todos,
Hace un tiempo publiqué un post en el que explicaba cómo podíamos programar copias de seguridad de nuestras listas de SharePoint utilizando Power Automate. En aquel ejemplo exportábamos los registros a un archivo CSV que posteriormente guardábamos en SharePoint.
PROGRAMAR COPIAS DE SEGURIDAD PARA UNA LISTA DE SHAREPOINT CON POWER AUTOMATE
Hoy vamos a ir un poco más allá. No solo vamos a generar automáticamente copias de seguridad de una lista de SharePoint, sino que también vamos a crear un segundo flujo que nos permita recuperar los registros almacenados en esas copias.
Para ello, vamos a utilizar archivos JSON, un formato que nos permitirá almacenar la información de nuestros registros y posteriormente recuperarla con Power Automate.
Vamos a trabajar con dos flujos:
- BACKUP_LISTAS_SHAREPOINT: encargado de generar periódicamente una copia de los registros y almacenarla en un archivo JSON.
- RESTAURAR_BACKUP_SHAREPOINT: encargado de leer el contenido de esos archivos y reconstruir los registros en otra lista de SharePoint.
Para nuestro ejemplo vamos a utilizar una lista de SharePoint llamada EMPLEADOS_ORIGEN, que tendrá la siguiente estructura:
| Columna | Tipo |
|---|---|
| Título | Una línea de texto |
| Departamento | Una línea de texto |
| Salario | Número |
Añadimos algunos empleados con diferentes departamentos y salarios. Estos serán los registros que posteriormente guardaremos en nuestras copias de seguridad.

También vamos a crear una segunda lista llamada EMPLEADOS_RESTAURADOS, donde recuperaremos los datos almacenados en los archivos JSON.
Esta segunda lista tendrá las mismas columnas, pero incorporaremos una adicional llamada IDOriginal, de tipo número.

¿Por qué añadimos esta columna?
Porque cuando creamos nuevos elementos en SharePoint, el sistema les asigna automáticamente un identificador interno que no tiene por qué coincidir con el que tenían en la lista original.
Por último, en nuestro sitio de SharePoint creamos una carpeta llamada BACKUPS_SHAREPOINT, dentro de la biblioteca de documentos.

Será aquí donde guardaremos automáticamente todos los archivos JSON que genere nuestro primer flujo.
PRIMER FLUJO: CREAR COPIAS DE SEGURIDAD AUTOMÁTICAS
PRIMER FLUJO: CREAR COPIAS DE SEGURIDAD AUTOMÁTICAS
Comenzamos creando un flujo de nube programado en Power Automate al que llamaremos BACKUP_LISTAS_SHAREPOINT. El objetivo es que, cada día, nuestro flujo recupere los registros de la lista de empleados, genere un archivo JSON con toda la información que queremos conservar y lo almacene automáticamente en una carpeta de SharePoint. Para ello, utilizamos el desencadenador Periodicidad, que configuramos para ejecutarse diariamente a las 08:00, seleccionando la zona horaria de Madrid. Evidentemente, podríamos modificar esta configuración para realizar las copias con cualquier otra frecuencia.
A continuación, añadimos la acción Obtener elementos del conector de SharePoint, que renombraremos como OBTENER_EMPLEADOS, y seleccionamos nuestro sitio y la lista EMPLEADOS_ORIGEN. Aquí debemos tener en cuenta que, por defecto, esta acción devuelve un número limitado de registros, por lo que, si trabajamos con listas grandes, es importante activar la paginación desde la configuración de la acción. En nuestro caso, establecemos un umbral de 10000 elementos para poder recuperar los registros dentro de ese límite.
Una vez obtenidos los empleados, vamos a preparar la información que queremos guardar en nuestro archivo de seguridad. Para ello, incorporamos la acción Seleccionar, dentro de Operaciones de datos, que renombraremos como GENERAR_JSON. En el campo Desde introducimos la siguiente expresión:
body('OBTENER_EMPLEADOS')?['value']
Con esta expresión recuperamos el array de registros devuelto por la acción anterior. A continuación, configuramos las columnas que queremos incluir en nuestra copia de seguridad, utilizando las siguientes expresiones:
| Clave | Expresión |
|---|---|
| ID | item()?['ID'] |
| Title | item()?['Title'] |
| Departamento | item()?['Departamento'] |
| Salario | item()?['Salario'] |
Como podéis observar, no estamos recuperando todas las propiedades que devuelve SharePoint, sino únicamente aquellas que nos interesan. De esta manera, generamos una estructura JSON más sencilla, en la que cada objeto representa un empleado con su identificador, nombre, departamento y salario. El resultado será similar al siguiente:
[
{
"ID": 1,
"Title": "Ana",
"Departamento": "Finanzas",
"Salario": 35000
},
{
"ID": 2,
"Title": "Luis",
"Departamento": "Tecnología",
"Salario": 42000
}
]
Ya tenemos preparada la información, así que el siguiente paso será guardarla en un archivo. Para ello, añadimos la acción Crear archivo de SharePoint y seleccionamos la carpeta BACKUPS_SHAREPOINT, que hemos creado anteriormente dentro de la biblioteca Documentos.
En el campo Nombre de archivo utilizamos la siguiente expresión:
concat(
'EMPLEADOS_',
formatDateTime(utcNow(),'yyyyMMdd_HHmmss'),
'.json'
)
Mediante concat() construimos dinámicamente el nombre del archivo, incorporando la fecha y hora de ejecución con formatDateTime() y utcNow(). Esta última función devuelve la fecha y hora en UTC, por lo que el nombre reflejará esa referencia horaria. Finalmente, añadimos la extensión .json, de forma que obtendremos nombres como EMPLEADOS_20261121_080000.json. Así evitamos sobrescribir los archivos anteriores y podemos mantener un histórico de nuestras copias de seguridad.
En el campo Contenido del archivo introducimos:
string(body('GENERAR_JSON'))
Con esta expresión convertimos la salida de GENERAR_JSON en una cadena de texto que guardaremos directamente en nuestro archivo JSON.

Con esto ya tenemos terminado nuestro primer flujo. Solo nos queda guardarlo y realizar una ejecución de prueba para comprobar que recupera correctamente los empleados y genera el correspondiente archivo JSON. Si accedemos a la carpeta BACKUPS_SHAREPOINT, veremos las copias creadas, cada una identificada con su fecha y hora de ejecución.

Y si lo abrimos:

Ya tenemos nuestro primer flujo funcionando y hemos conseguido generar automáticamente copias de seguridad de los registros de nuestra lista de SharePoint. Ahora vamos a realizar el proceso contrario, es decir, recuperar la información almacenada en esos archivos JSON y utilizarla para volver a crear los registros en otra lista.
Para ello, vamos a construir un segundo flujo de Power Automate al que llamaremos RESTAURAR_BACKUP_SHAREPOINT. En esta ocasión, en lugar de programar una ejecución periódica, vamos a utilizar un desencadenador que detecte cuándo se crea un nuevo archivo en nuestra carpeta BACKUPS_SHAREPOINT. De esta manera, cada vez que se genere una copia de seguridad, el segundo flujo podrá leer su contenido y recuperar automáticamente los empleados almacenados en ella.
En nuestro ejemplo utilizaremos la lista EMPLEADOS_RESTAURADOS, que hemos preparado anteriormente, para comprobar que todos los registros se recuperan correctamente. Así podremos realizar las pruebas sin modificar la información de nuestra lista original
SEGUNDO FLUJO: RESTAURAR LOS REGISTROS DESDE UN ARCHIVO JSON
Comenzamos creando un flujo de nube automatizado y seleccionamos el desencadenador de SharePoint Cuando se crea un archivo (solo propiedades). En su configuración indicamos nuestro sitio de SharePoint, seleccionamos la biblioteca Documentos y la carpeta BACKUPS_SHAREPOINT, donde estamos almacenando los archivos JSON generados por el primer flujo. Con esta configuración, Power Automate detectará automáticamente la creación de nuevos archivos en esa ubicación y pondrá en marcha el proceso de restauración.
El siguiente paso será recuperar las propiedades del archivo que ha provocado la ejecución. Para ello, añadimos la acción Obtener propiedades del archivo, que renombraremos como PROPIEDADES_BACKUP, y seleccionamos nuevamente nuestro sitio y la biblioteca Documentos. En el campo Id introducimos la siguiente expresión:
triggerOutputs()?['body/ID']
Con esta expresión recuperamos el identificador del elemento que acaba de crearse en la biblioteca de SharePoint. A continuación, añadimos la acción Obtener contenido de archivo, que renombraremos como LEER_BACKUP, y en el campo Identificador de archivo utilizamos:
body('PROPIEDADES_BACKUP')?['{Identifier}']
Aquí debemos tener en cuenta una diferencia importante, ya que el ID numérico de un elemento de SharePoint no es lo mismo que el identificador del archivo. En la primera acción utilizamos el ID para recuperar sus propiedades, mientras que en la segunda necesitamos el identificador que nos permite acceder a su contenido. De hecho, si utilizamos directamente el ID numérico en LEER_BACKUP, podemos encontrarnos con el error 404 - File not found. Por ello, recuperamos el valor {Identifier} de la acción anterior y conseguimos leer correctamente nuestro archivo JSON.
Una vez recuperado el archivo, necesitamos interpretar la información que contiene para poder trabajar con los registros almacenados. Para ello, incorporamos la acción Analizar JSON, dentro de Operaciones de datos, que renombraremos como ANALIZAR_JSON. En el campo Contenido introducimos la siguiente expresión:
body('LEER_BACKUP')
En nuestro caso, la acción LEER_BACKUP devuelve directamente el contenido del archivo como un array JSON, por lo que no necesitamos realizar ninguna conversión adicional. Esto es importante porque podemos encontrar ejemplos en los que se utilizan funciones como base64ToString() para interpretar el contenido de los archivos. Sin embargo, si Power Automate ya ha reconocido la estructura como un array, intentar acceder a una propiedad $content provocará un error.
A continuación, debemos indicar el esquema que utilizará Power Automate para interpretar nuestros datos. En el campo Esquema incorporamos el siguiente código:
{
"type": "array",
"items": {
"type": "object",
"properties": {
"ID": {
"type": "integer"
},
"Title": {
"type": ["string", "null"]
},
"Departamento": {
"type": ["string", "null"]
},
"Salario": {
"type": ["number", "null"]
}
}
}
}
Como podéis observar, estamos indicando que la información recibida es un array compuesto por diferentes objetos, donde cada objeto representa un empleado y contiene las propiedades ID, Title, Departamento y Salario. También permitimos valores nulos en algunas de las columnas, de manera que podamos procesar registros que no tengan todos sus campos informados. Esta estructura coincide con la que hemos generado en nuestro primer flujo mediante la acción GENERAR_JSON, por lo que ya tenemos preparada la información para comenzar a restaurar los registros.
Ahora que hemos interpretado correctamente el contenido del archivo, vamos a recorrer cada uno de los empleados y crear su correspondiente registro en nuestra lista de SharePoint. Para ello, añadimos la acción Aplicar a cada uno, que renombraremos como RECORRER_REGISTROS, y en el campo de entrada introducimos:
body('ANALIZAR_JSON')
Con esta expresión recuperamos el array generado por la acción anterior, de forma que Power Automate recorrerá cada uno de sus objetos. Dentro de este bucle añadimos la acción Crear elemento del conector de SharePoint, seleccionamos nuestro sitio y la lista EMPLEADOS_RESTAURADOS y configuramos los campos utilizando las siguientes expresiones:
| Campo | Expresión |
|---|---|
| Título | items('RECORRER_REGISTROS')?['Title'] |
| Departamento | items('RECORRER_REGISTROS')?['Departamento'] |
| Salario | items('RECORRER_REGISTROS')?['Salario'] |
| IDOriginal | items('RECORRER_REGISTROS')?['ID'] |
Mediante items('RECORRER_REGISTROS') accedemos al objeto que estamos procesando en cada iteración, mientras que las propiedades entre corchetes nos permiten recuperar el valor de cada columna. De esta manera, por cada empleado almacenado en el archivo JSON, Power Automate creará un nuevo elemento en nuestra lista de restauración.
Fijaos especialmente en la columna IDOriginal, ya que nos permitirá conservar el identificador que tenía cada empleado en el momento de realizar la copia de seguridad. Esto es necesario porque, al crear nuevamente los elementos, SharePoint asignará sus propios identificadores internos, que no tienen por qué coincidir con los originales.
Llegados a este punto, ya tenemos configurado nuestro segundo flujo, así que podemos realizar una prueba para comprobar que todo funciona correctamente. Para ello, dejamos vacía la lista EMPLEADOS_RESTAURADOS y ejecutamos el primer flujo para generar un nuevo archivo JSON en nuestra carpeta de copias de seguridad.


En cuanto se cree el archivo en BACKUPS_SHAREPOINT, el desencadenador del segundo flujo detectará su creación y comenzará a procesarlo. Primero recuperará sus propiedades y su contenido, después analizará la estructura JSON y, finalmente, recorrerá los registros almacenados para crear los empleados en nuestra lista de destino.
Si todo está correctamente configurado, al acceder a EMPLEADOS_RESTAURADOS podremos comprobar que los empleados se han recuperado con los mismos nombres, departamentos y salarios que tenían cuando se realizó la copia de seguridad. La única diferencia estará en los identificadores internos asignados por SharePoint, aunque habremos conservado los originales en la columna IDOriginal.

Con esto ya hemos conseguido completar el proceso de copia de seguridad y restauración. Mediante el primer flujo generamos automáticamente archivos JSON con los datos de nuestra lista y, mediante el segundo, recuperamos esa información para reconstruir los registros en SharePoint.
No obstante, debemos tener en cuenta que, tal y como hemos configurado nuestro ejemplo, cada nuevo archivo JSON provocará una restauración automática. Esto significa que, si la lista de destino ya contiene empleados de una ejecución anterior, volveremos a crearlos y terminaremos generando duplicados. Para evitarlo, podríamos incorporar una comprobación previa utilizando la columna IDOriginal, de manera que el flujo determinase si debe crear un nuevo registro o actualizar uno existente.
Otra posibilidad sería separar las copias de seguridad de las restauraciones, utilizando una carpeta específica para los archivos que queramos recuperar. Así podríamos seguir generando nuestras copias diariamente y ejecutar la restauración únicamente cuando lo necesitásemos.
En cualquier caso, con este ejemplo ya tenemos una base sobre la que podemos seguir trabajando y ampliar nuestro sistema en función de las necesidades de cada proyecto.
