{"id":675,"date":"2024-07-22T20:37:50","date_gmt":"2024-07-22T20:37:50","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=675"},"modified":"2024-07-22T20:54:58","modified_gmt":"2024-07-22T20:54:58","slug":"workdir","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/es\/wiki\/workdir\/","title":{"rendered":"WORKDIR"},"content":{"rendered":"

Understanding WORKDIR in Docker: An In-Depth Exploration<\/h1>\n

In the world of Docker, the WORKDIR<\/code> instruction plays a pivotal role in defining the working directory for subsequent commands in a 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>. By setting this directory, you simplify your 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>, making it cleaner and more maintainable, while also ensuring that file paths are relative to a defined space. This article delves into the specifics of WORKDIR<\/code>, its importance, best practices, and real-world applications, providing an extensive overview for both novice and advanced Docker users.<\/p>\n

What is WORKDIR?<\/h2>\n

The WORKDIR<\/code> instruction in a 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> specifies the working directory for any 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>, 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>, ENTRYPOINT<\/a><\/span>An entrypoint serves as the initial point of execution for an application or script. It defines where the program begins its process flow, ensuring proper initialization and resource management. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code>, COPY<\/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><\/code>, and ADD<\/a><\/span>The ADD instruction in Docker is a command used in Dockerfiles to copy files and directories from a host machine into a Docker image during the build process. It not only facilitates the transfer of local files but also provides additional functionality, such as automatically extracting compressed files and fetching remote files via HTTP or HTTPS. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> instructions that follow it. If the directory does not exist, WORKDIR<\/code> will create it for you. This instruction is crucial because it allows you to avoid using full paths in subsequent commands, leading to cleaner and more readable Dockerfiles.<\/p>\n

Syntax<\/h3>\n

The basic syntax of the WORKDIR<\/code> command is as follows:<\/p>\n

WORKDIR \/path\/to\/directory<\/code><\/pre>\n
Multiple WORKDIR Instructions<\/h3>\n
One of the unique features of WORKDIR<\/code> is that you can use it multiple times within a 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>. Each subsequent WORKDIR<\/code> command modifies the working directory relative to the previous one. This capability allows for organized directory structures and helps in navigating through complex multi-stage builds or applications with multiple services.<\/p>\n
Why Use WORKDIR?<\/h2>\n
Enhanced Readability<\/h3>\n
Using WORKDIR<\/code> leads to more readable and maintainable Dockerfiles. Instead of providing absolute paths for every command, you can rely on the relative paths, making it easier to understand the structure at a glance.<\/p>\n
Simplified Path Management<\/h3>\n
When dealing with multiple services or applications within a single 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>, managing paths can become cumbersome. By establishing a base working directory with WORKDIR<\/code>, you reduce the risk of errors and the complexity of specifying full paths.<\/p>\n
Directory Creation<\/h3>\n
As mentioned, if the specified directory does not already exist, WORKDIR<\/code> will create it. This feature is particularly useful in multi-stage builds where you may not necessarily want to scaffold your directory structure ahead of time.<\/p>\n
Layer Caching<\/h3>\n
Docker employs a layer caching mechanism to optimize build times. Efficient use of WORKDIR<\/code> can improve cache utilization, particularly when combined with other commands, such as COPY<\/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><\/code>. If the contents of the working directory do not change, Docker can use the cached layer for subsequent builds, speeding up the build process.<\/p>\n
Practical Use Cases<\/h2>\n
To better illustrate the power and flexibility of WORKDIR<\/code>, let\u2019s explore some practical use cases.<\/p>\n
Basic Example<\/h3>\n
Consider a simple web application setup. Below is an example 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> that uses WORKDIR<\/code> to manage the project files cleanly:<\/p>\n
FROM node:14\n\n# Set the working directory\nWORKDIR \/usr\/src\/app\n\n# Copy package.json and install dependencies\nCOPY package*.json .\/\nRUN npm install\n\n# Copy the rest of the application code\nCOPY . .\n\n# Expose the application port\nEXPOSE 8080\n\n# Start the application\nCMD [\"node\", \"server.js\"]<\/code><\/pre>\n
In this example, the WORKDIR<\/code> command sets the working directory to \/usr\/src\/app<\/code>. All subsequent commands will be executed within this directory, making the file paths cleaner and preventing any unintended issues with relative paths.<\/p>\n
Multi-Stage Builds<\/h3>\n
Docker’s multi-stage builds allow you to create smaller, more efficient images. When using multi-stage builds, WORKDIR<\/code> becomes even more useful for managing paths across different stages. Below is an example:<\/p>\n
# First stage: build\nFROM 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\nWORKDIR \/app\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> package*.json .\/\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\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> . .\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 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> build\n\n# Second stage: production\nFROM nginx:alpine\n\nWORKDIR \/usr\/share\/nginx\/html\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\/dist .<\/code><\/pre>\n
In this example, the first stage builds the application in \/app<\/code>, while the second stage uses WORKDIR<\/code> to set the path for the NGINX server. This clear separation helps maintain clarity and efficiency in both stages.<\/p>\n
Conditional Directory Creation<\/h3>\n
Another scenario where WORKDIR<\/code> shines is when you need to conditionally create directories based on your application\u2019s requirements. Consider the following:<\/p>\n
FROM python:3.9\n\n# Set the base work directory\nWORKDIR \/app\n\n# Create a subdirectory for code\nWORKDIR \/app\/src\n\n# Copy only the source code\nCOPY src\/ .\n\n# Create a directory for logs\nRUN mkdir -p \/app\/logs\n\n# Set up the command to run the app\nCMD [\"python\", \"main.py\"]<\/code><\/pre>\n
Here, WORKDIR<\/code> is effectively used to create \/app\/src<\/code> for source code and \/app\/logs<\/code> for logging. The use of mkdir -p<\/code> ensures that the logs directory is created if it doesn\u2019t exist, showcasing the flexibility of structuring the application.<\/p>\n
Best Practices<\/h2>\n
To maximize the benefits of WORKDIR<\/code>, follow these best practices:<\/p>\n
Use Descriptive Names<\/h3>\n
When defining the working directory, opt for names that clearly describe the purpose of the directory. This practice will aid in both readability and future maintenance.<\/p>\n
Keep Paths Consistent<\/h3>\n
When using multiple WORKDIR<\/code> commands, maintain a consistent path structure. This consistency prevents confusion and makes it easier for other developers to navigate through 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>.<\/p>\n
Leverage Build Arguments<\/h3>\n
In complex applications, consider using build arguments to set the working directory dynamically. This approach allows you to create versatile Dockerfiles that can adapt to different environments.<\/p>\n
ARG<\/a><\/span>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. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> APP_DIR=\/app\n\nWORKDIR ${APP_DIR}<\/code><\/pre>\n
Minimize Layers<\/h3>\n
Each command in a 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> creates a layer; hence, minimize the number of WORKDIR<\/code> commands when possible to reduce 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. However, balance this with the need for readability and maintainability.<\/p>\n
Common Pitfalls<\/h2>\n
Redundant WORKDIR<\/code> Usage<\/h3>\n
While it\u2019s nice to use WORKDIR<\/code> multiple times for clarity, overusing it can lead to redundancy. Avoid unnecessary WORKDIR<\/code> commands when the context doesn\u2019t change.<\/p>\n
Misunderstanding Relative Paths<\/h3>\n
When using multiple WORKDIR<\/code> commands, remember that each subsequent command modifies the context. Misunderstanding this can lead to unexpected behavior, especially when writing file paths.<\/p>\n
Neglecting Permissions<\/h3>\n
When dealing with different users within a Docker 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>, ensure that the WORKDIR<\/code> has the appropriate permissions set. This caution prevents issues where the application cannot access its working directory.<\/p>\n
Monitoring and Debugging with WORKDIR<\/h2>\n
When debugging Docker containers, understanding the current working directory can be crucial. You can verify your working directory by running the following command within a 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
docker exec -it  pwd<\/code><\/pre>\n
This command returns the current working directory, helping you ensure that your WORKDIR<\/code> is set as expected.<\/p>\n
Conclusion<\/h2>\n
The WORKDIR<\/code> instruction is more than just a convenience in Docker; it is a fundamental building block for clean, scalable, and maintainable Dockerfiles. By understanding its capabilities and best practices, developers can create efficient Docker images while avoiding common pitfalls. Whether you’re managing simple applications or complex multi-service architectures, leveraging WORKDIR<\/code> effectively will enhance both your development workflow and the operational efficiency of your Docker containers. <\/p>\n
As you continue to explore Docker, remember that a well-structured 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> not only simplifies builds but also contributes significantly to the overall reliability and performance of your applications. Embrace WORKDIR<\/code> as an essential tool in your Docker toolkit, and watch how it can transform your containerization process!<\/p>","protected":false},"excerpt":{"rendered":"
La instrucci\u00f3n `WORKDIR` en Dockerfile<\/a><\/span>Un Dockerfile es un script que contiene una serie de instrucciones para automatizar la creaci\u00f3n de im\u00e1genes Docker. Especifica la imagen base, las dependencias de la aplicaci\u00f3n y la configuraci\u00f3n, facilitando el despliegue consistente en diferentes entornos. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> establece el directorio de trabajo para las instrucciones posteriores. Simplifica la gesti\u00f3n de rutas, ya que todas las rutas relativas se resolver\u00e1n desde este directorio, mejorando la claridad de la compilaci\u00f3n.<\/p>","protected":false},"author":1,"featured_media":1464,"parent":0,"template":"","glossary-cat":[],"class_list":["post-675","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nWORKDIR - 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\/workdir\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"WORKDIR - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"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.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/es\/wiki\/workdir\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-22T20:54:58+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.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\/workdir\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/workdir\/\",\"name\":\"WORKDIR - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg\",\"datePublished\":\"2024-07-22T20:37:50+00:00\",\"dateModified\":\"2024-07-22T20:54:58+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/workdir\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/workdir\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg\",\"width\":800,\"height\":600,\"caption\":\"workdir-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/workdir\/#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\":\"WORKDIR\"}]},{\"@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":"WORKDIR - 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\/workdir\/","og_locale":"es_ES","og_type":"article","og_title":"WORKDIR - Dockerpros","og_description":"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.","og_url":"https:\/\/dockerpros.com\/es\/wiki\/workdir\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-22T20:54:58+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.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\/workdir\/","url":"https:\/\/dockerpros.com\/wiki\/workdir\/","name":"WORKDIR - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg","datePublished":"2024-07-22T20:37:50+00:00","dateModified":"2024-07-22T20:54:58+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/workdir\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/workdir\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/dockerpros.com\/wiki\/workdir\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/workdir_675.jpg","width":800,"height":600,"caption":"workdir-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/workdir\/#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":"WORKDIR"}]},{"@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\/675","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\/675\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media\/1464"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media?parent=675"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary-cat?post=675"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}