{"id":679,"date":"2024-07-22T20:37:51","date_gmt":"2024-07-22T20:37:51","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=679"},"modified":"2024-07-23T14:46:06","modified_gmt":"2024-07-23T14:46:06","slug":"arg","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/es\/wiki\/arg\/","title":{"rendered":"Argentina"},"content":{"rendered":"

Understanding ARG in Docker: A Comprehensive Guide<\/h1>\n

In Docker, ARG<\/code> is a directive used within Dockerfiles to define build-time variables that allow you to parameterize your builds. These variables can influence how an image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is constructed, enabling developers to create more flexible and reusable Docker images. Unlike environment variables (defined by the ENV<\/a><\/span>ENV, or Environmental Variables, are crucial in software development and system configuration. They store dynamic values that affect the execution environment, enabling flexible application behavior across different platforms. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> instruction), which persist in the running container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, ARG<\/code> values are only available during the image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> build process, making them suitable for use cases such as specifying versions of software, toggling features, or managing configuration settings without hardcoding them into Dockerfiles.<\/p>\n

The Role of ARG in Dockerfiles<\/h2>\n

The ARG<\/code> instruction helps facilitate the separation of configuration from code. By employing ARG<\/code>, developers can create images tailored to various environments (development, testing, production) without the need to maintain multiple Dockerfiles. This capability enhances maintainability and usability.<\/p>\n

For instance, consider a scenario where you need to build an application that links to different databases depending on the environment. Using ARG<\/code>, you can define a variable for the database connection string that can be passed at build-time. This approach not only simplifies the build process but also minimizes the risk of errors associated with hardcoded values.<\/p>\n

Syntax and Usage of ARG<\/h3>\n

The syntax for defining an ARG<\/code> variable is straightforward:<\/p>\n

ARG [=]<\/code><\/pre>\n
Here, is the name of the variable, and<\/code> is an optional parameter that provides a fallback value if none is specified during the build process.<\/p>\n
Example of Using ARG<\/h4>\n
FROM ubuntu:20.04\n\nARG APP_VERSION=1.0\nARG BUILD_ENV=production\n\nRUN echo \"Building version: $APP_VERSION in $BUILD_ENV environment\"<\/code><\/pre>\n
In this example, we have defined two ARG<\/code> variables: APP_VERSION<\/code> and BUILD_ENV<\/code>. If no values are provided at build-time, the Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> will default to 1.0<\/code> for APP_VERSION<\/code> and production<\/code> for BUILD_ENV<\/code>.<\/p>\n
Passing ARG Values at Build Time<\/h3>\n
When building a Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, you can pass values to ARG<\/code> using the --build-arg<\/code> flag. Here\u2019s how you can do it:<\/p>\n
docker build --build-arg APP_VERSION=2.0 --build-arg BUILD_ENV=staging .<\/code><\/pre>\n
In this command, we override the default values, specifying that we want to build version 2.0<\/code> in a staging<\/code> environment. The output of the RUN<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> command in the Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> will reflect these arguments.<\/p>\n
Availability and Scope of ARG Variables<\/h3>\n
It\u2019s crucial to understand the scope of ARG<\/code> variables. They are only available during the image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> build process and cannot be accessed at runtime within the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This is different from ENV<\/a><\/span>ENV, or Environmental Variables, are crucial in software development and system configuration. They store dynamic values that affect the execution environment, enabling flexible application behavior across different platforms. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> variables, which are available to both the build process and the running container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>\n
For instance, if you try to access an ARG<\/code> variable in a script that runs when the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is started, you will find that it is undefined. Here\u2019s an example to illustrate this point:<\/p>\n
FROM ubuntu:20.04\n\nARG APP_VERSION=1.0\n\nRUN echo \"Application version is $APP_VERSION\" > \/app_version.txt\n\nCMD [\"cat\", \"\/app_version.txt\"]<\/code><\/pre>\n
If you build this Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> and run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, you will see Application version is 1.0<\/code>. However, if you were to attempt to access APP_VERSION<\/code> in a command executed by the CMD<\/a><\/span>CMD, or Command Prompt, is a command-line interpreter in Windows operating systems. It allows users to execute commands, automate tasks, and manage system files through a text-based interface. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code>, it would yield nothing.<\/p>\n
Best Practices for Using ARG<\/h3>\n
To make the most of ARG<\/code> in your Dockerfiles, consider the following best practices:<\/p>\n
1. Default Values<\/h4>\n
Always provide sensible default values for your ARG<\/code> variables. This allows your image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to be built successfully even if no build-time arguments are specified.<\/p>\n
2. Limit Scope<\/h4>\n
Keep the number of ARG<\/code> directives to a minimum. Too many variables can lead to complexity and confusion. Only use them when necessary for configuration or customization.<\/p>\n
3. Documentation<\/h4>\n
Document your ARG<\/code> variables within the Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. Comments can help other developers understand the purpose of each variable, its default value, and how to override it during the build process.<\/p>\n
4. Use ENV for Runtime Variables<\/h4>\n
Remember that ARG<\/code> is not available at runtime. If you need configuration values at runtime, consider setting them as ENV<\/a><\/span>ENV, or Environmental Variables, are crucial in software development and system configuration. They store dynamic values that affect the execution environment, enabling flexible application behavior across different platforms. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> variables after defining ARG<\/code>:<\/p>\n
FROM ubuntu:20.04\n\nARG APP_VERSION=1.0\nENV APP_VERSION=${APP_VERSION}\n\nRUN echo \"Application version is $APP_VERSION\"\n\nCMD [\"echo\", \"Running version $APP_VERSION\"]<\/code><\/pre>\n
In this setup, the APP_VERSION<\/code> is available during both the build and runtime.<\/p>\n
Use Cases for ARG<\/h3>\n
1. Building Multiple Versions of Software<\/h4>\n
You can use ARG<\/code> to build different versions of software depending on the build context. This is particularly useful for CI\/CD pipelines where you may want to build images for various versions automatically.<\/p>\n
FROM node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:14\n\nARG NODE_VERSION=14\n\nRUN<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> npx node@${NODE_VERSION} -v<\/code><\/pre>\n
2. Conditional Installation of Dependencies<\/h4>\n
You can conditionally install software package dependencies based on build-time arguments. This capability can help optimize the final image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> size by including only necessary components:<\/p>\n
FROM python:3.8\n\nARG INSTALL_DEPS=true\n\nRUN if [ \"$INSTALL_DEPS\" = \"true\" ]; then \n        pip install -r requirements.txt; \n    fi<\/code><\/pre>\n
3. Multi-Stage Builds<\/h4>\n
In multi-stage builds, you can use ARG<\/code> to pass parameters between different build stages:<\/p>\n
FROM node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:14 AS builder\n\nARG NODE_ENV=production\nENV<\/a><\/span>ENV, or Environmental Variables, are crucial in software development and system configuration. They store dynamic values that affect the execution environment, enabling flexible application behavior across different platforms. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> NODE_ENV=${NODE_ENV}\n\nCOPY<\/a><\/span>COPY is a command in computer programming and data management that facilitates the duplication of files or data from one location to another, ensuring data integrity and accessibility. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> . \/app\nWORKDIR<\/a><\/span>The `WORKDIR` instruction in Dockerfile sets the working directory for subsequent instructions. It simplifies path management, as all relative paths will be resolved from this directory, enhancing build clarity. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> \/app\nRUN<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> npm install --only=${NODE_ENV}\n\nFROM nginx:alpine\n\nCOPY<\/a><\/span>COPY is a command in computer programming and data management that facilitates the duplication of files or data from one location to another, ensuring data integrity and accessibility. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> --from=builder \/app\/build \/usr\/share\/nginx\/html<\/code><\/pre>\n
Limitations of ARG<\/h3>\n
While ARG<\/code> is a powerful feature, it comes with certain limitations:<\/p>\n
    \n
  1. Scope<\/strong>: As mentioned earlier, ARG<\/code> variables cannot be accessed in the resulting container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. Keep this in mind when designing your Dockerfiles.<\/li>\n
  2. Build-time Only<\/strong>: Since ARG<\/code> is only available during the build phase, any dynamic configuration that you expect to change at runtime cannot utilize ARG<\/code>.<\/li>\n
  3. No Runtime Persistence<\/strong>: Any value assigned to an ARG<\/code> variable cannot persist beyond the build context, which limits its utility for dynamic behavior during container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> execution.<\/li>\n<\/ol>\n
    Advanced Topics: ARG in Docker Compose and CI\/CD Contexts<\/h3>\n
    Using ARG in Docker Compose<\/h4>\n
    Docker Compose<\/a><\/span>Docker Compose is a tool for defining and running multi-container Docker applications using a YAML file. It simplifies deployment, configuration, and orchestration of services, enhancing development efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> allows you to define build arguments directly in your docker-compose.yml<\/code> file. Here\u2019s how you can do it:<\/p>\n
    version: \"3.8\"\nservices:\n  myapp:\n    build:\n      context: .\n      args:\n        APP_VERSION: \"2.0\"<\/code><\/pre>\n
    In this setup, when you run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> docker-compose up<\/code>, the specified APP_VERSION<\/code> will be passed to the build process.<\/p>\n
    ARG in CI\/CD Pipelines<\/h4>\n
    In continuous integration and deployment pipelines, ARG<\/code> becomes invaluable for building images dynamically based on the environment. You can configure your CI\/CD tool (e.g., Jenkins, GitLab CI, GitHub Actions) to pass different ARG<\/code> values based on the branch, version tags, or even commit messages.<\/p>\n
    For example, using GitHub Actions, you can define a job to build your Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:<\/p>\n
    jobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Check out code\n        uses: actions\/checkout@v2\n\n      - name: Build Docker image\n        run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>: docker build --build-arg APP_VERSION=${{ github.sha }} .<\/code><\/pre>\n
    In this case, each build will automatically use the commit SHA as the APP_VERSION<\/code>, allowing you to track versions easily.<\/p>\n
    Conclusion<\/h3>\n
    The ARG<\/code> directive in Docker provides a powerful mechanism for parameterizing build processes, enabling developers to create more dynamic and flexible Docker images. By understanding its syntax, best practices, and appropriate use cases, you can leverage ARG<\/code> to enhance your Dockerfiles and optimize your container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> workflows. While it has limitations, particularly in terms of scope and runtime availability, when used correctly, ARG<\/code> can significantly improve your containerized application development experience. <\/p>\n
    Incorporating ARG<\/code> into your Docker strategy not only promotes cleaner and more maintainable code but also aligns with the growing need for adaptable and scalable software deployment practices. As you continue to explore Docker, consider how ARG<\/code> can be an integral part of your image-building strategy and how it can contribute to more robust CI\/CD pipelines.<\/p>","protected":false},"excerpt":{"rendered":"
    ARG es una directiva utilizada dentro de los Dockerfiles para definir variables de tiempo de construcci\u00f3n que permiten parametrizar tus construcciones. Estas variables pueden influir en c\u00f3mo se imagen<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> se construye, lo que permite a los desarrolladores crear im\u00e1genes de Docker m\u00e1s flexibles y reutilizables.<\/p>","protected":false},"author":1,"featured_media":1472,"parent":0,"template":"","glossary-cat":[],"class_list":["post-679","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nARG - Dockerpros<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/dockerpros.com\/es\/wiki\/arg\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"ARG - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"ARG is a directive used within Dockerfiles to define build-time variables that allow you to parameterize your builds. These variables can influence how an image is constructed, enabling developers to create more flexible and reusable Docker images.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/es\/wiki\/arg\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T14:46:06+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"800\" \/>\n\t<meta property=\"og:image:height\" content=\"600\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/arg\/\",\"name\":\"ARG - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg\",\"datePublished\":\"2024-07-22T20:37:51+00:00\",\"dateModified\":\"2024-07-23T14:46:06+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/arg\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg\",\"width\":800,\"height\":600,\"caption\":\"arg-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/arg\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/dockerpros.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Glossary\",\"item\":\"https:\/\/dockerpros.com\/fr\/wiki\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"ARG\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/dockerpros.com\/#website\",\"url\":\"https:\/\/dockerpros.com\/\",\"name\":\"Dockerpros\",\"description\":\"DockerPros \u2013 Your Ultimate Docker Resource Hub\",\"publisher\":{\"@id\":\"https:\/\/dockerpros.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/dockerpros.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"width\":532,\"height\":114,\"caption\":\"Dockerpros\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"ARG - Dockerpros","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/dockerpros.com\/es\/wiki\/arg\/","og_locale":"es_ES","og_type":"article","og_title":"ARG - Dockerpros","og_description":"ARG is a directive used within Dockerfiles to define build-time variables that allow you to parameterize your builds. These variables can influence how an image is constructed, enabling developers to create more flexible and reusable Docker images.","og_url":"https:\/\/dockerpros.com\/es\/wiki\/arg\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T14:46:06+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tiempo de lectura":"6 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/arg\/","url":"https:\/\/dockerpros.com\/wiki\/arg\/","name":"ARG - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg","datePublished":"2024-07-22T20:37:51+00:00","dateModified":"2024-07-23T14:46:06+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/arg\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/arg\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/dockerpros.com\/wiki\/arg\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/arg_679.jpg","width":800,"height":600,"caption":"arg-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/arg\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/dockerpros.com\/"},{"@type":"ListItem","position":2,"name":"Glossary","item":"https:\/\/dockerpros.com\/fr\/wiki\/"},{"@type":"ListItem","position":3,"name":"ARG"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Profesionales de Docker","description":"DockerPros \u2013 Tu centro definitivo de recursos Docker","publisher":{"@id":"https:\/\/dockerpros.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/dockerpros.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Profesionales de Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","width":532,"height":114,"caption":"Dockerpros"},"image":{"@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary\/679","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary\/679\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media\/1472"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media?parent=679"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary-cat?post=679"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}