{"id":1366,"date":"2024-07-23T12:39:03","date_gmt":"2024-07-23T12:39:03","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1366"},"modified":"2024-07-23T12:39:03","modified_gmt":"2024-07-23T12:39:03","slug":"dockerfile-progress","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-progress\/","title":{"rendered":"Dockerfile \u2013progress"},"content":{"rendered":"

Comprendere Dockerfile \u2013progress: una guida completa\n\nIntroduzione\n\nDocker \u00e8 uno strumento potente per creare, distribuire e eseguire applicazioni in contenitori. Uno degli aspetti chiave di Docker \u00e8 il Dockerfile, un file di testo che contiene tutte le istruzioni necessarie per creare un'immagine Docker. In questo articolo, esploreremo in dettaglio l'opzione \u2013progress del Dockerfile, che fornisce un feedback dettagliato durante il processo di build.\n\nCos'\u00e8 il Dockerfile?\n\nPrima di addentrarci nell'opzione \u2013progress, \u00e8 importante capire cos'\u00e8 un Dockerfile. Un Dockerfile \u00e8 un file di testo che contiene una serie di istruzioni su come costruire un'immagine Docker. Ogni istruzione nel Dockerfile crea un nuovo livello nell'immagine, e Docker esegue queste istruzioni in sequenza per creare l'immagine finale.\n\nL'opzione \u2013progress\n\nL'opzione \u2013progress \u00e8 un flag che pu\u00f2 essere utilizzato con il comando docker build. Questo flag fornisce un feedback dettagliato durante il processo di build, mostrando lo stato di avanzamento di ogni istruzione nel Dockerfile. Questo pu\u00f2 essere particolarmente utile per capire cosa sta succedendo durante il processo di build, soprattutto se qualcosa va storto.\n\nCome utilizzare l'opzione \u2013progress\n\nPer utilizzare l'opzione \u2013progress, \u00e8 sufficiente aggiungerla al comando docker build. Ad esempio:\n\n```\ndocker build --progress=plain -t myimage .\n```\n\nIn questo esempio, stiamo costruendo un'immagine Docker chiamata \"myimage\" e stiamo utilizzando l'opzione \u2013progress con il valore \"plain\". Questo mostrer\u00e0 un feedback dettagliato per ogni istruzione nel Dockerfile.\n\nValori possibili per l'opzione \u2013progress\n\nL'opzione \u2013progress pu\u00f2 assumere diversi valori:\n\n- plain: Mostra un feedback dettagliato per ogni istruzione nel Dockerfile.\n- auto: Mostra un feedback dettagliato solo se l'output non \u00e8 un terminale (ad esempio, se viene reindirizzato a un file).\n- tty: Mostra un feedback dettagliato solo se l'output \u00e8 un terminale.\n\nConclusione\n\nL'opzione \u2013progress del Dockerfile \u00e8 uno strumento potente che pu\u00f2 aiutare a capire meglio il processo di build di Docker. Fornendo un feedback dettagliato per ogni istruzione nel Dockerfile, pu\u00f2 aiutare a identificare e risolvere i problemi pi\u00f9 rapidamente. Ricorda di utilizzare questa opzione la prossima volta che costruisci un'immagine Docker!<\/h1>\n

The Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> --progress<\/code> L'opzione \u00e8 una potente funzionalit\u00e0 introdotta in Docker 18.09 che migliora il processo di build consentendo agli utenti di selezionare il formato di output delle informazioni sullo stato di avanzamento della build. Questo argomento della riga di comando permette agli sviluppatori di personalizzare il modo in cui Docker presenta l'output della build, semplificando il tracciamento dello stato di avanzamento delle build multistadio o di grandi dimensioni. immagine<\/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> compilazioni. Man mano che i container continuano a diffondersi nello sviluppo software moderno, padroneggiare --progress<\/code> L'opzione \u00e8 essenziale per chiunque desideri ottimizzare i propri flussi di lavoro Docker e migliorare la leggibilit\u00e0 dei propri processi di build.<\/p>\n

L'evoluzione dell'output della build Docker<\/h2>\n

Docker \u00e8 in continua evoluzione dalla sua nascita nel 2013, e con ogni iterazione, la comunit\u00e0 di sviluppo ha cercato modi per migliorare l'efficienza e l'usabilit\u00e0 dei suoi strumenti. Prima dell'introduzione del --progress<\/code> In precedenza, l'output di build di Docker era limitato a un unico formato che poteva risultare ingombrante e difficile da interpretare, specialmente per build complessi. Gli utenti spesso dovevano setacciare un muro di testo per trovare le informazioni rilevanti, il che non solo era dispendioso in termini di tempo, ma poteva anche portare a errori o avvisi persi.<\/p>\n

The introduction of the --progress<\/code> option addressed these issues by allowing developers to specify how they want to visualize the build process. This change marked a significant improvement in user experience, as it helped streamline the flow of information during builds.<\/p>\n

Vari Formati di Progresso<\/h2>\n

The --progress<\/code> flag accepts three different options, each catering to different needs and preferences:<\/p>\n

    \n
  1. \n

    Auto<\/strong>: This is the default behavior of Docker, where it automatically selects the output format based on whether the output is being sent to a terminal or a non-terminal environment. It provides a smart mix of human-readable output and machine-parsable formats.<\/p>\n<\/li>\n

  2. \n

    Plain<\/strong>: This option outputs the build progress as simple text. It is beneficial when the user wants minimal distraction from the build logs, providing straightforward output without any additional formatting or color coding. This format is particularly useful in automated environments, such as CI\/CD pipelines, where logs need to be captured and analyzed without any extraneous information.<\/p>\n<\/li>\n

  3. \n

    TTY<\/strong>: Questo formato fornisce un output pi\u00f9 interattivo e visivamente accattivante, sfruttando i colori ANSI e le barre di avanzamento per rappresentare le fasi di compilazione. \u00c8 ideale per gli utenti che preferiscono una visualizzazione pi\u00f9 coinvolgente e dinamica del processo di compilazione, rendendo pi\u00f9 facile identificare la fase corrente e l'avanzamento complessivo.<\/p>\n<\/li>\n<\/ol>\n

    Specifica il formato di output\n\n\u00c8 possibile specificare il formato di output utilizzando l'opzione -t. Ad esempio, per convertire un file di testo in formato PDF, \u00e8 possibile utilizzare il seguente comando:\n\npandoc input.txt -t pdf -o output.pdf\n\nIn questo caso, l'opzione -t specifica il formato di output come PDF e l'opzione -o specifica il nome del file di output.\n\n\u00c8 anche possibile specificare il formato di output utilizzando l'estensione del file di output. Ad esempio, per convertire un file di testo in formato PDF, \u00e8 possibile utilizzare il seguente comando:\n\npandoc input.txt -o output.pdf\n\nIn questo caso, l'estensione del file di output (.pdf) indica a Pandoc di convertire il file in formato PDF.\n\nPandoc supporta una vasta gamma di formati di output, tra cui PDF, HTML, EPUB, DOCX e molti altri. Per un elenco completo dei formati di output supportati, consultare la documentazione di Pandoc.<\/h3>\n

    Per usare il --progress<\/code> option, you can specify it directly in the docker build<\/code> command. For example:<\/p>\n

    docker build --progress=plain -t myimage:latest .<\/code><\/pre>\n
    In questo comando, la compilazione verr\u00e0 eseguita utilizzando il formato di output plain. Per passare al formato TTY, il comando sarebbe simile a questo:<\/p>\n
    docker build --progress=tty -t myimage:latest .<\/code><\/pre>\n
    Con l'opzione automatica, puoi semplicemente correre<\/a><\/span>\"RUN\" si riferisce a un comando in diversi linguaggi di programmazione e sistemi operativi per eseguire un programma o script specificato. Avvia processi, fornendo un ambiente controllato per l'esecuzione dei compiti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:<\/p>\n
    docker build --progress=auto -t myimage:latest .<\/code><\/pre>\n
    Applicazioni Pratiche e Vantaggi<\/h2>\n
    Leggibilit\u00e0 migliorata<\/h3>\n
    Uno dei vantaggi pi\u00f9 immediati dell'utilizzo del --progress<\/code> option is enhanced readability. By selecting the output format that best suits your needs, you can make your build logs easier to digest. For example, in a team environment, when multiple developers are collaborating on a project, clear and well-formatted logs can significantly improve communication and understanding.<\/p>\n
    Debug Migliorato<\/h3>\n
    When building complex Docker images, especially those involving multiple stages or intricate dependency graphs, it\u2019s crucial to be able to pinpoint issues quickly. The plain output format provides a clean and concise view of each build step, allowing developers to identify and resolve errors faster. This is particularly useful in CI\/CD pipelines, where automated builds are frequent, and any delays can hinder overall productivity.<\/p>\n
    Flessibilit\u00e0 nell'Integrazione Continua\/Distribuzione Continua<\/h3>\n
    Per le organizzazioni che adottano pratiche CI\/CD, la scelta del formato di output pu\u00f2 essere fondamentale. Molti sistemi CI\/CD catturano i log per l'analisi, e avere la possibilit\u00e0 di utilizzare un output semplice pu\u00f2 semplificare questo processo, rendendo pi\u00f9 facile cercare nei log parole chiave o errori specifici. D'altra parte, se si desidera una visualizzazione pi\u00f9 dettagliata e ricca, TTY pu\u00f2 essere abilitato durante le sessioni di revisione manuale, fornendo agli sviluppatori approfondimenti sul processo di build.<\/p>\n
    Customizing for Different Environments<\/h3>\n
    Diversi ambienti di sviluppo e produzione possono avere esigenze distinte quando si tratta di registrazione e output. Ad esempio, un ambiente di sviluppo locale potrebbe trarre vantaggio dal formato TTY, mentre un ambiente di produzione CI\/CD potrebbe richiedere il formato plain. Con il --progress<\/code> Il flag offre la flessibilit\u00e0 di personalizzare gli output in base al tuo ambiente specifico.<\/p>\n
    Best Practices for Using \u2013progress\n\nThe \u2013progress option is a powerful tool for monitoring the progress of your rsync transfers. However, it's important to use it judiciously to avoid overwhelming your terminal with too much information. Here are some best practices for using \u2013progress:\n\n1. Use \u2013progress for large transfers: If you're transferring a large number of files or very large files, \u2013progress can be helpful for monitoring the progress of the transfer. However, if you're transferring a small number of files, \u2013progress may not be necessary.\n\n2. Use \u2013info=progress2 for a cleaner output: If you find the output of \u2013progress to be too verbose, you can use \u2013info=progress2 instead. This option provides a cleaner output that shows the overall progress of the transfer, rather than the progress of each individual file.\n\n3. Use \u2013human-readable for easier-to-read output: The \u2013human-readable option can be used in conjunction with \u2013progress to display file sizes in a more readable format (e.g., \"1.2G\" instead of \"1234567890\").\n\n4. Use \u2013partial to keep partially transferred files: If a transfer is interrupted, rsync will normally delete any partially transferred files. However, if you use the \u2013partial option, rsync will keep these files, allowing you to resume the transfer later.\n\n5. Use \u2013append to resume interrupted transfers: If a transfer is interrupted and you've used the \u2013partial option, you can use the \u2013append option to resume the transfer from where it left off.\n\n6. Use \u2013stats to get a summary of the transfer: After the transfer is complete, you can use the \u2013stats option to get a summary of the transfer, including the total number of files transferred, the total size of the files, and the amount of time it took to complete the transfer.\n\n7. Use \u2013verbose for more detailed output: If you want more detailed output during the transfer, you can use the \u2013verbose option. This will display additional information about the transfer, such as the names of the files being transferred.\n\n8. Use \u2013dry-run to test the transfer: Before running a transfer, you can use the \u2013dry-run option to test the transfer without actually transferring any files. This can be useful for checking that the source and destination paths are correct and that the transfer will work as expected.\n\n9. Use \u2013exclude to exclude certain files or directories: If you want to exclude certain files or directories from the transfer, you can use the \u2013exclude option. This can be useful for excluding temporary files or other files that you don't want to transfer.\n\n10. Use \u2013include to include certain files or directories: If you want to include certain files or directories in the transfer, you can use the \u2013include option. This can be useful for including specific files or directories that you want to transfer, even if they would normally be excluded by other options.\n\nBy following these best practices, you can use the \u2013progress option effectively to monitor the progress of your rsync transfers and ensure that they complete successfully.<\/h2>\n
    Mentre il --progress<\/code> l'opzione aggiunge un valore significativo al processo di build Docker, \u00e8 essenziale adottare alcune best practice per massimizzare i suoi benefici:<\/p>\n
    1. Scegli il formato giusto per il contesto<\/h3>\n
    Valuta sempre il tuo contesto prima di selezionare un formato di output. Per lo sviluppo locale, TTY potrebbe essere pi\u00f9 coinvolgente, mentre per gli ambienti CI\/CD, l'opzione semplice \u00e8 consigliabile. Comprendere il tuo pubblico e il caso d'uso ti aiuter\u00e0 a prendere decisioni informate.<\/p>\n
    2. Combinalo con altre tecniche di ottimizzazione della build<\/h3>\n
    The --progress<\/code> option should not be seen as a standalone solution but rather as part of a larger strategy for optimizing Docker builds. Combine it with multi-stage builds, proper caching strategies, and efficient layer management to create a robust and efficient build process.<\/p>\n
    3. Monitor Build Performance<\/h3>\n
    Quando si utilizza il --progress<\/code> option, keep an eye on build performance. If you notice significant slowdowns with a particular format, consider switching to another. The output format might affect how Docker interacts with the underlying system, which could lead to performance implications.<\/p>\n
    4. Document Your Choices<\/h3>\n
    In team environments, documenting decisions regarding output formats is crucial. If a specific output format is preferred for CI\/CD processes, make sure to communicate this through documentation or team meetings. Clear guidelines help in maintaining consistency across builds.<\/p>\n
    5. Sfrutta gli Strumenti Esterni<\/h3>\n
    Per una registrazione e un monitoraggio pi\u00f9 avanzati, prendi in considerazione l'integrazione di strumenti esterni che possano gestire i log di Docker in modo pi\u00f9 efficace. Strumenti come ELK Stack<\/a><\/span>A stack is a data structure that operates on a Last In, First Out (LIFO) principle, where the most recently added element is the first to be removed. It supports two primary operations: push and pop. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> (Elasticsearch, Logstash, and Kibana) or Grafana can help visualize and analyze logs generated during Docker builds, providing deeper insights into performance and potential issues.<\/p>\n
    Common Use Cases<\/h2>\n
    1. Ambiente di Sviluppo<\/h3>\n
    During the development phase, developers are often making frequent changes and rebuilding images. Using the TTY format can make these interactions more engaging, allowing developers to see real-time progress and any errors that may arise quickly.<\/p>\n
    2. Continuous Integration<\/h3>\n
    Nei pipeline CI, le build devono essere automatizzate per garantire efficienza. Il formato semplice aiuta a creare log puliti che sono facili da analizzare. Questo \u00e8 particolarmente utile per registrare gli artefatti di build e gli errori, rendendo pi\u00f9 semplice per gli sviluppatori risolvere i problemi delle build fallite senza dover setacciare log ingombranti.<\/p>\n
    3. Debugging<\/h3>\n
    When troubleshooting issues in Docker images, utilizing the plain format allows developers to see a straightforward representation of each build step. This aids significantly in pinpointing the exact step where a failure might occur, facilitating rapid diagnosis and resolution.<\/p>\n
    4. Distribuzione in Produzione<\/h3>\n
    Quando si distribuiscono immagini Docker in produzione, \u00e8 imperativo avere log accurati e puliti per scopi di controllo. Utilizzando il formato plain durante le build di produzione, i team possono garantire che i log siano minimi e contengano informazioni rilevanti senza rumore eccessivo.<\/p>\n
    Conclusione<\/h2>\n
    The --progress<\/code> option in Dockerfiles is a critical feature for modern software development practices, particularly in containerized environments. By understanding and leveraging the different output formats, developers can enhance the readability of build logs, improve debugging processes, and tailor their builds to their specific environments. Adopting best practices around this feature will not only streamline your Docker workflows but will also contribute to a more efficient development process overall.<\/p>\n
    Man mano che l'ecosistema Docker continua ad evolversi, rimanere al passo con tali miglioramenti e incorporarli nel proprio flusso di lavoro diventa fondamentale. Che tu sia un utente Docker esperto o nuovo alla containerizzazione, padroneggiare --progress<\/code> L'opzione porter\u00e0 senza dubbio a esperienze di sviluppo pi\u00f9 produttive e piacevoli.<\/p>","protected":false},"excerpt":{"rendered":"
    L'opzione `\u2013progress` in Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> migliora l'output di build consentendo agli utenti di scegliere tra diversi formati di output, tra cui \u201cauto\u201d, \u201cplain\u201d e \u201ctty\u201d, facilitando il debug e il monitoraggio.<\/p>","protected":false},"author":1,"featured_media":2045,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1366","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -progress - 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\/it\/wiki\/dockerfile-progress\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -progress - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--progress` flag in Dockerfile enhances the build output by allowing users to choose between different output formats. Options include "auto," "plain," and "tty," facilitating easier debugging and monitoring.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-progress\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.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=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/\",\"name\":\"Dockerfile -progress - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg\",\"datePublished\":\"2024-07-23T12:39:03+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-progress-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#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 –progress\"}]},{\"@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\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@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 -progress - 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\/it\/wiki\/dockerfile-progress\/","og_locale":"it_IT","og_type":"article","og_title":"Dockerfile -progress - Dockerpros","og_description":"The `--progress` flag in Dockerfile enhances the build output by allowing users to choose between different output formats. Options include \"auto,\" \"plain,\" and \"tty,\" facilitating easier debugging and monitoring.","og_url":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-progress\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tempo di lettura stimato":"6 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/","name":"Dockerfile -progress - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg","datePublished":"2024-07-23T12:39:03+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-progress_1366.jpg","width":800,"height":600,"caption":"dockerfile-progress-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-progress\/#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 –progress"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Esperti Docker","description":"DockerPros \u2013 Il tuo punto di riferimento definitivo per 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":"it-IT"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Esperti Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@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\/it\/wp-json\/wp\/v2\/glossary\/1366","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1366\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media\/2045"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media?parent=1366"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary-cat?post=1366"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}