{"id":3420,"date":"2025-10-06T16:12:05","date_gmt":"2025-10-06T14:12:05","guid":{"rendered":"https:\/\/tecnologia.euroinnova.com\/automatiza-tus-tareas-con-makefile-guia-esencial-para-proyectos-multiplataforma\/"},"modified":"2025-10-07T14:49:34","modified_gmt":"2025-10-07T12:49:34","slug":"automatiza-tus-tareas-con-makefile","status":"publish","type":"post","link":"https:\/\/tecnologia.euroinnova.com\/fr\/automatiza-tus-tareas-con-makefile","title":{"rendered":"Automatisez vos t\u00e2ches avec Makefile : Guide essentiel pour les projets multiplateformes"},"content":{"rendered":"

Makefile es una herramienta cl\u00e1sica y potente que permite automatizar tareas repetitivas dentro de proyectos de software. Aunque naci\u00f3 en el mundo del desarrollo en C, sigue siendo ampliamente utilizada hoy en d\u00eda en entornos modernos, gracias a su simplicidad y versatilidad.<\/span><\/o_p><\/p>\n

En esta gu\u00eda descubrir\u00e1s c\u00f3mo aprovechar Makefile para definir comandos reutilizables, mantener orden en tus proyectos multiplataforma y mejorar la productividad sin depender de herramientas externas complejas.<\/span><\/o_p><\/p>\n

Qu\u00e9 es Makefile y para qu\u00e9 sirve<\/strong><\/span><\/o_p><\/h2>\n

A <\/span>Makefile<\/span> es un archivo de texto que contiene reglas y comandos que se ejecutan de forma autom\u00e1tica al invocar el comando <\/span>make<\/span>. Estas reglas suelen usarse para compilar programas, pero tambi\u00e9n pueden automatizar cualquier tarea del desarrollo: limpiar archivos, ejecutar tests, construir contenedores, copiar recursos, etc.<\/span><\/o_p><\/p>\n

Al usar <\/span>make<\/span>, puedes estandarizar y simplificar el proceso de desarrollo, evitando repetir comandos largos y propensos a errores. Su funcionamiento se basa en un sistema de dependencias: cada tarea se ejecuta solo si sus archivos han cambiado, lo que lo hace eficiente y r\u00e1pido.<\/span><\/o_p><\/p>\n

Ventajas de usar Makefile en tus proyectos<\/strong><\/span><\/o_p><\/h2>\n

Integrar Makefile en tus flujos de trabajo aporta m\u00faltiples beneficios, especialmente en proyectos colaborativos o que deben ejecutarse en diferentes sistemas operativos.<\/span><\/o_p><\/p>\n

    \n
  • Ahorro de tiempo y errores<\/strong>: Los comandos habituales (compilar, formatear, testear, limpiar) se encapsulan en reglas reutilizables, lo que reduce la posibilidad de cometer errores al escribirlos manualmente y ahorra tiempo en tareas repetitivas. Un <\/span>make test<\/span>, por ejemplo, puede ejecutar m\u00faltiples validaciones sin necesidad de recordar su sintaxis exacta.<\/o_p><\/span><\/li>\n
  • Portabilidad y estandarizaci\u00f3n<\/strong>: Un \u00fanico Makefile puede ejecutarse sin cambios en diferentes entornos (Linux, macOS, WSL), lo que facilita el trabajo en equipo y la continuidad entre desarrolladores. Adem\u00e1s, act\u00faa como una documentaci\u00f3n viva de las tareas disponibles en el proyecto, reduciendo la dependencia de instrucciones externas.<\/o_p><\/span><\/li>\n
  • Facilidad de mantenimiento<\/strong>: Centralizar todas las tareas en un Makefile permite modificar f\u00e1cilmente los flujos de trabajo a medida que el proyecto evoluciona. En lugar de actualizar scripts dispersos o comandos en la documentaci\u00f3n, solo necesitas modificar las reglas en un \u00fanico archivo.<\/o_p><\/span><\/li>\n
  • Integraci\u00f3n con CI\/CD<\/strong>: Muchas plataformas de integraci\u00f3n continua (CI), como GitHub Actions, GitLab CI o Jenkins, pueden ejecutar directamente tareas definidas en un Makefile, lo que simplifica la configuraci\u00f3n de pipelines. Adem\u00e1s, facilita la ejecuci\u00f3n local de los mismos pasos definidos para el despliegue autom\u00e1tico.<\/o_p><\/span><\/li>\n
  • Independencia de herramientas externas<\/strong>: A diferencia de otros gestores de tareas como <\/span>npm scripts<\/span>, <\/span>Rake<\/span> o <\/span>Invoke<\/span>, Makefile no requiere instalar dependencias adicionales. Viene preinstalado en la mayor\u00eda de entornos Unix y es muy liviano, lo que lo convierte en una soluci\u00f3n accesible y robusta para todo tipo de proyectos.<\/o_p><\/span><\/li>\n<\/ul>\n

    Estructura b\u00e1sica de un Makefile<\/strong><\/span><\/o_p><\/h2>\n

    Un Makefile est\u00e1 compuesto por reglas que definen qu\u00e9 debe hacerse y cu\u00e1ndo. Cada regla tiene un objetivo, una lista de dependencias y uno o m\u00e1s comandos que se ejecutan si las dependencias est\u00e1n actualizadas o han cambiado.<\/span><\/o_p><\/p>\n

    La estructura general de una regla es la siguiente:<\/span><\/o_p><\/p>\n

    objetivo: dependencias<\/span>
    <TAB>comando_1<\/span>
    <TAB>comando_2<\/span><\/p>\n

    En este esquema:<\/span><\/o_p><\/p>\n

      \n
    • objetivo<\/span> es el nombre de la tarea o archivo que queremos generar.<\/o_p><\/span><\/li>\n
    • dependencias<\/span> son los archivos de los que depende ese objetivo.<\/o_p><\/span><\/li>\n
    • Los comandos (que deben ir precedidos por tabulaci\u00f3n, no espacios) se ejecutan solo si alguna dependencia ha cambiado.<\/o_p><\/span><\/li>\n<\/ul>\n

      Este modelo no solo permite automatizar compilaciones, sino tambi\u00e9n tareas personalizadas como formateo, pruebas o despliegue, lo que hace que Makefile sea \u00fatil incluso fuera del \u00e1mbito de C o C++.<\/span><\/o_p><\/p>\n

      Estructura b\u00e1sica de un Makefile<\/strong><\/span><\/o_p><\/h2>\n

      Un Makefile se compone de una serie de reglas que definen tareas automatizadas. Cada regla sigue una estructura est\u00e1ndar: un nombre de tarea (target), una lista opcional de dependencias y uno o varios comandos que se ejecutan cuando se invoca dicha tarea.<\/span><\/o_p><\/p>\n

      Sintaxis general<\/strong><\/span><\/o_p><\/h3>\n

      La estructura b\u00e1sica de una regla en Makefile es la siguiente:<\/span><\/o_p><\/p>\n

      target: dependencias<\/span>
          <tabulaci\u00f3n>comando<\/span><\/p>\n

      Cada comando debe ir precedido por una tabulaci\u00f3n (no espacios), ya que Make distingue entre ambos. Es com\u00fan que un proyecto tenga tareas como <\/span>build<\/span>, <\/span>test<\/span>, <\/span>clean<\/span> o <\/span>run<\/span>, definidas de esta manera.<\/span><\/o_p><\/p>\n

      Ejemplo simple<\/strong><\/span><\/o_p><\/h3>\n

      Un ejemplo b\u00e1sico para automatizar la compilaci\u00f3n de un archivo en C podr\u00eda verse as\u00ed:<\/span><\/o_p><\/p>\n

      all: programa<\/span><\/p>\n

      programa: main.c<\/span>
          gcc -o programa main.c<\/span>
      clean:<\/span>
          rm -f programa<\/span><\/p>\n

      Este Makefile permite compilar el programa con solo ejecutar <\/span>make<\/span>, ya que <\/span>all<\/span> es la primera regla definida y, por tanto, se ejecuta por defecto.<\/span><\/o_p><\/p>\n

      Variables y comentarios en Makefile<\/strong><\/span><\/o_p><\/h2>\n

      Para mantener tus Makefiles limpios y reutilizables, puedes definir variables y a\u00f1adir comentarios explicativos. Las variables te permiten centralizar rutas, nombres de archivos u opciones de compilaci\u00f3n que se usan en varias reglas.<\/span><\/o_p><\/p>\n

      C\u00f3mo definir y usar variables<\/strong><\/span><\/o_p><\/h3>\n

      Las variables en Makefile se definen con el signo igual (<\/span>=<\/span>) y se invocan usando <\/span>$(nombre_variable)<\/span>. Esto permite modificar f\u00e1cilmente configuraciones sin tocar cada regla por separado.<\/span><\/o_p><\/p>\n

      CC = gcc<\/span>
      SRC = main.c<\/span>
      OUT = programa<\/span>
      all:<\/span>
          $(CC) -o $(OUT) $(SRC)<\/span><\/p>\n

      En este ejemplo, si m\u00e1s adelante cambias el nombre del archivo fuente o el compilador, solo tendr\u00e1s que hacerlo en una l\u00ednea.<\/span><\/o_p><\/p>\n

      A\u00f1adir comentarios explicativos<\/strong><\/span><\/o_p><\/h3>\n

      Puedes documentar tu Makefile utilizando el s\u00edmbolo <\/span>#<\/span>, igual que en muchos lenguajes de scripting. Esto resulta \u00fatil para mantener el c\u00f3digo claro y comprensible.<\/span><\/o_p><\/p>\n

      # Definimos las variables para simplificar cambios<\/span>
      CC = gcc<\/span>
      SRC = main.c<\/span>
      OUT = programa<\/span><\/p>\n

      La combinaci\u00f3n de variables y comentarios facilita la colaboraci\u00f3n y el mantenimiento del proyecto, especialmente en entornos de trabajo compartido.<\/span><\/o_p><\/p>\n

      Uso de condicionales y funciones b\u00e1sicas<\/strong><\/span><\/o_p><\/h2>\n

      Makefile tambi\u00e9n permite utilizar condicionales y funciones que te ayudan a gestionar comportamientos diferentes seg\u00fan el entorno o las condiciones del proyecto. Esto hace que tu archivo sea m\u00e1s din\u00e1mico y flexible.<\/span><\/o_p><\/p>\n

      Condicionales en Makefile<\/strong><\/span><\/o_p><\/h3>\n

      Puedes definir condiciones utilizando directivas como <\/span>ifeq<\/span>, <\/span>ifneq<\/span>, <\/span>ifdef<\/span> o <\/span>ifndef<\/span>. Estas permiten ejecutar reglas o definir variables solo si se cumplen ciertas condiciones.<\/span><\/o_p><\/p>\n

      ifeq ($(DEBUG),1)<\/span>
          CFLAGS = -g<\/span>
      else<\/span>
          CFLAGS = -O2<\/span>
      endif<\/span><\/p>\n

      Esto es \u00fatil, por ejemplo, si quieres tener reglas distintas para entornos de desarrollo y producci\u00f3n.<\/span><\/o_p><\/p>\n

      Funciones para operaciones comunes<\/strong><\/span><\/o_p><\/h3>\n

      Makefile incorpora funciones integradas que te permiten manipular cadenas, buscar archivos o recorrer listas. Algunas de las m\u00e1s comunes son <\/span>subst<\/span>, <\/span>wildcard<\/span> o <\/span>foreach<\/span>.<\/span><\/o_p><\/p>\n

      SRC = $(wildcard *.c)<\/span>
      OBJ = $(subst .c,.o,$(SRC))<\/span><\/p>\n

      Estas funciones ampl\u00edan el poder de los Makefiles para adaptarse a necesidades m\u00e1s complejas, sin salir del propio entorno de construcci\u00f3n.<\/span><\/o_p><\/p>\n

      Integraci\u00f3n de Makefile en entornos multiplataforma<\/strong><\/span><\/o_p><\/h2>\n

      Una de las grandes ventajas de Makefile es su capacidad para ejecutarse en diferentes sistemas operativos con pocas modificaciones. Esto lo convierte en una herramienta ideal para proyectos colaborativos y entornos de trabajo heterog\u00e9neos.<\/span><\/o_p><\/p>\n

      Adaptar Makefile a Windows, Linux y macOS<\/strong><\/span><\/o_p><\/h3>\n

      Aunque el n\u00facleo de los comandos Make es multiplataforma, algunas \u00f3rdenes espec\u00edficas pueden variar seg\u00fan el sistema operativo. Para solventar esto, puedes usar condicionales para ejecutar instrucciones distintas en cada entorno:<\/span><\/o_p><\/p>\n

      ifeq ($(OS),Windows_NT)<\/span>
          RM = del<\/span>
      else<\/span>
          RM = rm -f<\/span>
      endif<\/span><\/p>\n

      Tambi\u00e9n es buena pr\u00e1ctica evitar rutas absolutas o comandos que solo funcionen en un sistema (como <\/span>rm<\/span> en Unix y <\/span>del<\/span> en Windows), optando en su lugar por soluciones compatibles o condicionales adaptadas.<\/span><\/o_p><\/p>\n

      Buenas pr\u00e1cticas para entornos compartidos<\/strong><\/span><\/o_p><\/h3>\n

      Si tu proyecto se desarrolla en equipo, es importante escribir Makefiles que funcionen sin errores fuera de tu m\u00e1quina local. Aqu\u00ed algunas recomendaciones:<\/span><\/o_p><\/p>\n

        \n
      • Usa variables para definir rutas y comandos, evitando valores codificados directamente.<\/o_p><\/span><\/li>\n
      • A\u00f1ade comentarios claros para que otros desarrolladores entiendan cada regla.<\/o_p><\/span><\/li>\n
      • Verifica que las dependencias necesarias (como compiladores o scripts) est\u00e9n disponibles en los sistemas destino.<\/o_p><\/span><\/li>\n
      • Prueba el Makefile en distintos entornos antes de integrarlo en un flujo de trabajo continuo.<\/o_p><\/span><\/li>\n<\/ul>\n

        Con una estructura bien pensada, tu Makefile podr\u00e1 ejecutarse sin problemas en cualquier equipo del proyecto, mejorando la productividad y reduciendo errores.<\/span><\/o_p><\/p>\n

        Automatizaci\u00f3n de tareas comunes con Makefile<\/strong><\/span><\/o_p><\/h2>\n

        Makefile no se limita a compilar c\u00f3digo: tambi\u00e9n permite automatizar tareas repetitivas del d\u00eda a d\u00eda en el desarrollo de software. Desde lanzar pruebas hasta limpiar archivos temporales, su versatilidad lo convierte en un aliado potente para desarrolladores y equipos t\u00e9cnicos.<\/span><\/o_p><\/p>\n

        Ejemplos pr\u00e1cticos de tareas automatizadas<\/strong><\/span><\/o_p><\/h3>\n

        Estas son algunas tareas habituales que puedes automatizar f\u00e1cilmente con Makefile:<\/span><\/o_p><\/p>\n

        test:<\/span>
            pytest tests\/<\/span><\/p>\n

        clean:<\/span>
            rm -rf *.pyc __pycache__\/<\/span><\/p>\n

        lint:<\/span>
            flake8 src\/<\/span><\/p>\n

        build:<\/span>
            python setup.py sdist bdist_wheel<\/span><\/p>\n

        Cada una de estas reglas puede ejecutarse con <\/span>make tarea<\/span>, permitiendo a cualquier miembro del equipo lanzar procesos estandarizados sin recordar comandos complejos.<\/span><\/o_p><\/p>\n

        Personalizaci\u00f3n y reutilizaci\u00f3n<\/strong><\/span><\/o_p><\/h3>\n

        Una gran ventaja de usar Makefile es su flexibilidad. Puedes definir variables reutilizables para rutas, comandos o flags, y usar comodines (<\/span>%<\/span>) o patrones para reglas gen\u00e9ricas que se aplican a m\u00faltiples archivos. Adem\u00e1s, puedes dividir tus Makefiles en archivos separados e incluirlos mediante <\/span>include<\/span> para mantener la organizaci\u00f3n.<\/span><\/o_p><\/p>\n

        Esta capacidad de adaptaci\u00f3n convierte a Make en una herramienta que escala bien desde peque\u00f1os scripts hasta procesos complejos de compilaci\u00f3n, pruebas y despliegue continuo.<\/span><\/o_p><\/p>\n

        Makefile en proyectos multiplataforma<\/strong><\/span><\/o_p><\/h2>\n

        Uno de los puntos fuertes de Makefile es su compatibilidad con entornos diversos, lo que lo hace ideal para proyectos que deben ejecutarse en sistemas Linux, macOS y Windows. Aunque Make fue dise\u00f1ado inicialmente para sistemas Unix, hoy en d\u00eda existen formas fiables de utilizarlo en entornos multiplataforma.<\/span><\/o_p><\/p>\n

        Compatibilidad y adaptabilidad<\/strong><\/span><\/o_p><\/h3>\n

        En sistemas macOS y Linux, Make suele estar preinstalado o se puede instalar f\u00e1cilmente desde los gestores de paquetes del sistema (<\/span>apt<\/span>, <\/span>brew<\/span>, etc.). En Windows, puedes utilizar herramientas como Make para Windows<\/strong>, MSYS2<\/strong>, Git Bash<\/strong> o WSL (Windows Subsystem for Linux)<\/strong> para trabajar con Makefiles de forma funcional y consistente.<\/span><\/o_p><\/p>\n

        Adem\u00e1s, los comandos definidos en un Makefile pueden adaptarse usando condicionales o variables espec\u00edficas para cada sistema operativo, evitando errores en entornos mixtos y facilitando la colaboraci\u00f3n entre desarrolladores.<\/span><\/o_p><\/p>\n

        Buenas pr\u00e1cticas para portabilidad<\/strong><\/span><\/o_p><\/h3>\n

        Para asegurar que tu Makefile funcione sin problemas en cualquier plataforma, puedes seguir estas recomendaciones:<\/span><\/o_p><\/p>\n

          \n
        • Usa comandos compatibles con POSIX siempre que sea posible.<\/o_p><\/span><\/li>\n
        • Define variables como <\/span>SHELL<\/span> para usar Bash u otro int\u00e9rprete expl\u00edcito.<\/o_p><\/span><\/li>\n
        • Evita rutas absolutas y opta por rutas relativas al proyecto.<\/o_p><\/span><\/li>\n
        • A\u00f1ade comentarios explicativos para aclarar dependencias espec\u00edficas del sistema.<\/o_p><\/span><\/li>\n
        • Considera separar reglas cr\u00edticas por entorno y seleccionar las adecuadas con condicionales <\/span>ifeq<\/span>.<\/o_p><\/span><\/li>\n<\/ul>\n

          Estas pr\u00e1cticas ayudan a mantener un entorno de desarrollo coherente y evitan conflictos entre sistemas operativos diferentes, algo clave en equipos distribuidos o proyectos open source.<\/span><\/o_p><\/p>\n

          Estructura b\u00e1sica de un Makefile<\/strong><\/span><\/o_p><\/h2>\n

          Un Makefile est\u00e1 compuesto por reglas que definen c\u00f3mo se deben ejecutar ciertas tareas. Cada regla suele incluir un objetivo, sus dependencias y una o m\u00e1s l\u00edneas de comandos que se ejecutan si las dependencias cambian o no existen.<\/span><\/o_p><\/p>\n

          Elementos principales de un Makefile<\/strong><\/span><\/o_p><\/h3>\n

          Los componentes m\u00e1s comunes en un Makefile son:<\/span><\/o_p><\/p>\n

            \n
          • Objetivo (target):<\/strong> Es el nombre de la tarea o archivo a generar.<\/o_p><\/span><\/li>\n
          • Dependencias:<\/strong> Archivos o condiciones que deben cumplirse antes de ejecutar la regla.<\/o_p><\/span><\/li>\n
          • Recetas:<\/strong> Comandos que se ejecutan para cumplir el objetivo (deben comenzar con una tabulaci\u00f3n, no espacios).<\/o_p><\/span><\/li>\n<\/ul>\n

            Una regla t\u00edpica tiene esta forma:<\/span><\/o_p><\/p>\n

            objetivo: dependencias<\/span>
                <comandos><\/span><\/p>\n

            Ejemplo simple de estructura<\/strong><\/span><\/o_p><\/h3>\n

            Este Makefile compila un programa a partir de un archivo fuente:<\/span><\/o_p><\/p>\n

            app: main.c<\/span>
                gcc main.c -o app<\/span><\/p>\n

            Si <\/span>main.c<\/span> cambia o no existe <\/span>app<\/span>, Make ejecutar\u00e1 el comando para compilarlo. Si nada ha cambiado, Make no har\u00e1 nada, lo que lo convierte en una herramienta eficiente para automatizar solo cuando es necesario.<\/span><\/o_p><\/p>\n

            Uso de variables y reutilizaci\u00f3n de c\u00f3digo<\/strong><\/span><\/o_p><\/h2>\n

            Una de las grandes ventajas de Make es la posibilidad de definir variables para evitar repeticiones y facilitar la reutilizaci\u00f3n del c\u00f3digo. Esto no solo mejora la legibilidad de los Makefiles, sino que permite hacerlos m\u00e1s flexibles y adaptables a cambios futuros.<\/span><\/o_p><\/p>\n

            Puedes declarar variables con <\/span>=<\/span> y luego reutilizarlas en varias reglas. Es especialmente \u00fatil para definir compiladores, flags o rutas comunes en un proyecto.<\/span><\/o_p><\/p>\n

            CC=gcc<\/span>
            CFLAGS=-Wall -g<\/span><\/p>\n

            main: main.o utils.o<\/span>
                $(CC) $(CFLAGS) -o main main.o utils.o<\/span><\/p>\n

            En este ejemplo, <\/span>CC<\/span> es la variable que representa el compilador (<\/span>gcc<\/span>), mientras que <\/span>CFLAGS<\/span> incluye las opciones comunes de compilaci\u00f3n. Luego, se reutilizan en la regla de construcci\u00f3n.<\/span><\/o_p><\/p>\n

            Tambi\u00e9n puedes crear variables para nombres de archivos, directorios o comandos complejos, y modificar su valor seg\u00fan el entorno si es necesario.<\/span><\/o_p><\/p>\n

            SOURCES=main.c utils.c<\/span>
            OBJECTS=$(SOURCES:.c=.o)<\/span><\/p>\n

            all: $(OBJECTS)<\/span>
                $(CC) $(CFLAGS) -o main $(OBJECTS)<\/span><\/p>\n

            Este enfoque facilita mantener tu Makefile limpio y f\u00e1cil de mantener incluso en proyectos grandes.<\/span><\/o_p><\/p>\n

            Crear tareas personalizadas con Make<\/strong><\/span><\/o_p><\/h2>\n

            Adem\u00e1s de compilar programas, Make permite definir tareas personalizadas que automatizan procesos comunes del proyecto, como limpiar archivos temporales, ejecutar tests o generar documentaci\u00f3n. Estas tareas son simplemente reglas sin dependencias ni comandos de compilaci\u00f3n.<\/span><\/o_p><\/p>\n

            Por ejemplo, puedes crear una tarea <\/span>clean<\/span> para eliminar los archivos <\/span>.o<\/span> y binarios generados durante la compilaci\u00f3n, lo que mantiene el entorno limpio entre ejecuciones:<\/span><\/o_p><\/p>\n

            clean:<\/span>
                rm -f *.o main<\/span><\/p>\n

            Tambi\u00e9n puedes definir tareas como <\/span>test<\/span>, <\/span>install<\/span> o <\/span>deploy<\/span>, seg\u00fan las necesidades de tu proyecto. Basta con asignarles un nombre y los comandos que deseas ejecutar cuando invoques esa tarea con <\/span>make nombre_tarea<\/span>.<\/span><\/o_p><\/p>\n

            test:<\/span>
                python3 -m unittest discover tests<\/span><\/p>\n

            Estas tareas convierten el Makefile en una herramienta vers\u00e1til de automatizaci\u00f3n, m\u00e1s all\u00e1 del contexto de compilaci\u00f3n.<\/span><\/o_p><\/p>\n

            Compatibilidad multiplataforma y buenas pr\u00e1cticas<\/strong><\/span><\/o_p><\/h2>\n

            Cuando trabajas en equipos con sistemas operativos distintos (Linux, macOS, Windows con WSL), es importante tener en cuenta ciertas consideraciones para que el Makefile funcione correctamente en todos los entornos.<\/span><\/o_p><\/p>\n

            Entre las pr\u00e1cticas recomendadas se incluyen:<\/span><\/o_p><\/p>\n

            ","protected":false},"excerpt":{"rendered":"

            Makefile es una herramienta cl\u00e1sica y potente que permite automatizar tareas repetitivas dentro de proyectos de software. Aunque naci\u00f3 en […]<\/p>\n","protected":false},"author":2,"featured_media":1192,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1],"tags":[],"class_list":["post-3420","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sin-categorizar"],"acf":[],"_links":{"self":[{"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/posts\/3420","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/comments?post=3420"}],"version-history":[{"count":0,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/posts\/3420\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/media\/1192"}],"wp:attachment":[{"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/media?parent=3420"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/categories?post=3420"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/tecnologia.euroinnova.com\/fr\/wp-json\/wp\/v2\/tags?post=3420"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}