{"id":1322,"date":"2024-07-23T12:20:39","date_gmt":"2024-07-23T12:20:39","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1322"},"modified":"2024-07-23T12:23:27","modified_gmt":"2024-07-23T12:23:27","slug":"dockerfile-shell","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-shell\/","title":{"rendered":"Dockerfile SHELL"},"content":{"rendered":"

Understanding the Dockerfile SHELL Instruction: A Deep Dive<\/h1>\n

In Docker, the SHELL instruction defines the command line shell that is used to execute any subsequent 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> instructions 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 default, Docker uses \/bin\/sh -c<\/code> as the shell; however, the SHELL instruction allows developers to customize this shell to meet their specific requirements or preferences. This functionality is particularly useful when working with scripts that require a different shell environment or when utilizing specific shell features that are not available in the default shell.<\/p>\n

Importance of the SHELL Instruction<\/h2>\n

The SHELL instruction is crucial in 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> design because it directly influences how commands are executed 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> build process. The default shell may not support certain syntax or commands that are available in other shells like Bash, Zsh, or PowerShell. By specifying a different shell, developers can leverage the full power of their chosen shell environment. This flexibility is especially important in multi-stage builds, where different stages might require different shell features for optimal performance or compatibility.<\/p>\n

Syntax of the SHELL Instruction<\/h2>\n

The SHELL instruction follows a straightforward syntax:<\/p>\n

SHELL [\"executable\", \"parameters\"]<\/code><\/pre>\n
For example, to use Bash as the shell for subsequent 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> commands, you would specify it like this:<\/p>\n
SHELL [\"\/bin\/bash\", \"-c\"]<\/code><\/pre>\n
It’s important to note that the SHELL instruction affects all subsequent 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> commands until overridden by another SHELL instruction. This characteristic allows for structured and organized Dockerfiles where different stages can utilize different shells if required.<\/p>\n
Practical Use Cases<\/h2>\n
While the SHELL instruction might appear simple, its applications are vast. Below are some practical scenarios where the SHELL instruction can be applied effectively:<\/p>\n
1. Leveraging Shell Features<\/h3>\n
Different shells come with unique features that can be advantageous in specific scenarios. For instance, Bash supports arrays, which can simplify handling multiple items. Consider a situation where you need to set up multiple environment variables:<\/p>\n
SHELL [\"\/bin\/bash\", \"-c\"]\nRUN myarray=(value1 value2 value3) && \n    for item in \"${myarray[@]}\"; do \n        echo \"Processing $item\"; \n    done<\/code><\/pre>\n
Here, you can see how arrays streamline the process compared to using a simple for<\/code> loop in a shell that doesn\u2019t support arrays.<\/p>\n
2. Using Custom Shells<\/h3>\n
In some environments, especially those that require specialized functionality, developers may want to use shells that fit their needs better. For instance, in a Windows environment, you might want to use PowerShell:<\/p>\n
SHELL [\"powershell\", \"-Command\"]\nRUN Write-Host \"Hello from PowerShell\"<\/code><\/pre>\n
This allows you to utilize PowerShell commands and scripts within your 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> effectively.<\/p>\n
3. Multi-Stage Builds<\/h3>\n
Multi-stage builds are a vital feature in Docker that allows for the creation of smaller, more efficient images. In such scenarios, different stages might require different shell environments. For example, during the build phase, you might want to use Bash for more complex command sequences, while in the final production 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 may prefer a smaller shell. <\/p>\n
Here’s an example of using different shells in a multi-stage build<\/a><\/span>A multi-stage build is a Docker optimization technique that enables the separation of build and runtime environments. By using multiple FROM statements in a single Dockerfile, developers can streamline image size and enhance security by excluding unnecessary build dependencies in the final image. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:<\/p>\n
# Build stage\nFROM ubuntu:20.04 AS builder\nSHELL [\"\/bin\/bash\", \"-c\"]\nRUN apt-get update && apt-get install -y build-essential\n\n# Final stage\nFROM ubuntu:20.04\nSHELL [\"\/bin\/sh\", \"-c\"]\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 \/usr\/local\/bin\/myapp \/usr\/local\/bin\/myapp<\/code><\/pre>\n
In this example, the builder stage uses Bash, while 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> uses the default shell.<\/p>\n
Best Practices when Using SHELL<\/h2>\n
While the SHELL instruction provides flexibility, it’s essential to follow best practices to ensure that your Dockerfiles remain maintainable and efficient.<\/p>\n
1. Limit the Scope of SHELL<\/h3>\n
Only change the shell when necessary. If 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> can achieve its objectives using the default shell, stick with it. This helps maintain compatibility and reduces the complexity of 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>.<\/p>\n
2. Use SHELL Early<\/h3>\n
If you know that a certain stage requires a specific shell, it’s often best to declare the SHELL instruction at the beginning of that stage. This makes it clear to anyone reading 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> what to expect.<\/p>\n
3. Document Changes<\/h3>\n
Since the SHELL instruction affects all subsequent 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> commands, it can lead to confusion if not properly documented. Adding comments to indicate changes in the shell environment helps others (and your future self) understand the context:<\/p>\n
# Using Bash for scripting complex build commands\nSHELL [\"\/bin\/bash\", \"-c\"]\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> .\/build.sh<\/code><\/pre>\n
4. Avoid Shell-Specific Syntax in Default Shells<\/h3>\n
If you change the shell, ensure that your commands are compatible with that shell. Avoid using syntax specific to one shell in 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> commands intended for the default shell. This practice helps avoid build failures stemming from shell incompatibility.<\/p>\n
Common Pitfalls with SHELL<\/h2>\n
Despite its simplicity, the SHELL instruction can lead to some common pitfalls that developers should be aware of.<\/p>\n
1. Shell Compatibility Issues<\/h3>\n
One of the biggest issues developers face is shell compatibility. Commands that work in one shell may not work in another. Always test 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> thoroughly after changing the shell.<\/p>\n
2. Unintended Consequences of State Changes<\/h3>\n
Remember that the state of your shell can change between 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> commands. For instance, if you define a variable in one 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> command, it won’t persist to the next unless you export it or use a different approach to save states, such as writing to a file.<\/p>\n
SHELL [\"\/bin\/bash\", \"-c\"]\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> VAR=value && echo $VAR  # This will not work in the next 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> command\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> echo $VAR  # This will be empty<\/code><\/pre>\n
Make sure to export variables if they need to persist:<\/p>\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> export VAR=value && echo $VAR\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> echo $VAR  # This will still be empty<\/code><\/pre>\n
3. Overusing SHELL<\/h3>\n
While it\u2019s tempting to switch shells frequently throughout 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> for different commands, this can lead to confusion and complexity. Limit the use of SHELL to sections of 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> where it is genuinely required.<\/p>\n
Testing and Debugging SHELL Commands<\/h2>\n
When working with SHELL instructions, effective testing and debugging are essential to ensure that 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> behaves as expected. Here are some strategies for testing 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> with SHELL commands:<\/p>\n
1. Multi-Stage Builds for Testing<\/h3>\n
You can use multi-stage builds to test your SHELL changes without affecting 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>. By creating an intermediate stage, you can check whether your commands work as intended before proceeding to 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> build.<\/p>\n
2. Use Docker Build Options<\/h3>\n
Leverage Docker build options such as --no-cache<\/code> to ensure that your build doesn’t use cached layers. This option can help catch issues that arise after changing the SHELL instruction:<\/p>\n
docker build --no-cache -t myimage .<\/code><\/pre>\n
3. Incorporate Shell Debugging Tools<\/h3>\n
If you\u2019re using a shell like Bash, consider incorporating debugging options, such as set -x<\/code>, within your 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> commands. This will print each command before execution, making it easier to trace errors.<\/p>\n
SHELL [\"\/bin\/bash\", \"-c\"]\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> set -x && my_command_that_might_fail<\/code><\/pre>\n
4. Utilize Docker Containers for Testing<\/h3>\n
Testing your commands in an interactive 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> can provide a hands-on way to ensure that your SHELL commands work as expected. Start a 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> from your base 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
docker 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> -it myimage \/bin\/bash<\/code><\/pre>\n
This gives you a direct interface to execute commands and troubleshoot issues.<\/p>\n
Conclusion<\/h2>\n
The SHELL instruction in Dockerfiles is a powerful feature that allows for enhanced flexibility and functionality when building 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> images. By leveraging different shells, developers can utilize specific syntax or features tailored to their needs, ultimately leading to more efficient 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> management. <\/p>\n
However, with this power comes responsibility. Best practices, such as keeping the shell change scope limited, documenting changes, and being aware of potential pitfalls, are crucial for maintaining readable and maintainable Dockerfiles. By understanding and effectively utilizing the SHELL instruction, developers can harness the full potential of Docker, leading to streamlined workflows and robust containerized applications.<\/p>\n
In the ever-evolving landscape of containerization and DevOps, mastering the intricacies of 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> instructions, including SHELL, empowers developers to build optimized and effective 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> solutions. Whether you’re orchestrating complex builds or ensuring compatibility across environments, the SHELL instruction is an invaluable tool in your Docker toolbox<\/a><\/span>Docker Toolbox is a legacy solution for running Docker on older Windows and macOS systems. It includes Docker Machine, Docker CLI, and Kitematic, enabling container management without native Docker support. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>","protected":false},"excerpt":{"rendered":"
Die Dockerfile<\/a><\/span>Eine Dockerfile ist ein Skript, das eine Reihe von Anweisungen zur Automatisierung der Erstellung von Docker-Images enth\u00e4lt. Sie gibt das Basis-Image, die Anwendungsabh\u00e4ngigkeiten und die Konfiguration an und erm\u00f6glicht so eine konsistente Bereitstellung \u00fcber verschiedene Umgebungen hinweg. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> SHELL instruction allows users to define the command-line shell used for the RUN<\/a><\/span>\"RUN\" bezeichnet einen Befehl in verschiedenen Programmiersprachen und Betriebssystemen, um ein angegebenes Programm oder Skript auszuf\u00fchren. Er initiiert Prozesse und stellt eine kontrollierte Ausf\u00fchrungsumgebung f\u00fcr die Aufgabenbereitstellung bereit. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> Anweisungen im Build-Prozess. Diese Flexibilit\u00e4t erm\u00f6glicht die Ausf\u00fchrung spezifischer Shell-Funktionen oder Skripte.<\/p>","protected":false},"author":1,"featured_media":1959,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1322","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile SHELL - 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\/de\/wiki\/dockerfile-shell\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile SHELL - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The Dockerfile SHELL instruction allows users to define the command-line shell used for the RUN instructions in the build process. This flexibility enables the execution of specific shell features or scripts.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-shell\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:27+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.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=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data1\" content=\"6\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/\",\"name\":\"Dockerfile SHELL - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg\",\"datePublished\":\"2024-07-23T12:20:39+00:00\",\"dateModified\":\"2024-07-23T12:23:27+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-shell-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#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\":\"Dockerfile SHELL\"}]},{\"@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\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@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":"Dockerfile SHELL - 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\/de\/wiki\/dockerfile-shell\/","og_locale":"de_DE","og_type":"article","og_title":"Dockerfile SHELL - Dockerpros","og_description":"The Dockerfile SHELL instruction allows users to define the command-line shell used for the RUN instructions in the build process. This flexibility enables the execution of specific shell features or scripts.","og_url":"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-shell\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:27+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Gesch\u00e4tzte Lesezeit":"6\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/","name":"Dockerfile SHELL - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg","datePublished":"2024-07-23T12:20:39+00:00","dateModified":"2024-07-23T12:23:27+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-shell_1322.jpg","width":800,"height":600,"caption":"dockerfile-shell-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-shell\/#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":"Dockerfile SHELL"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Docker-Profis","description":"DockerPros \u2013 Ihr umfassender Docker-Ressourcen-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":"de"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Docker-Profis","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"de","@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\/de\/wp-json\/wp\/v2\/glossary\/1322","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary\/1322\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media\/1959"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media?parent=1322"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary-cat?post=1322"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}