{"subject_id":"3a3cc48d009981b9b858e41d4281e392","topico":"Docker: imagem × contêiner, Dockerfile (CMD × ENTRYPOINT), camadas, volumes, multi-stage","stems":["Julgue os itens seguintes, no que se refere a contêineres e gerência de configuração de softwares.","Na configuração de um ambiente de desenvolvimento para um novo projeto, é necessário definir variáveis de ambiente específicas a fim de garantir que a aplicação funcione corretamente em diferentes ambientes (desenvolvimento, teste e produção). Para isso, decidiu-se, utilizando o Docker, criar um contêiner e definir as variáveis de ambiente necessárias. Com base na situação hipotética apresentada, julgue os itens a seguir, relativos às práticas DevOps.","A respeito de gerência de contêineres e segurança com Docker, julgue os itens a seguir.","Julgue os itens seguintes, no que se refere a arquiteturas de contêiner e orquestradores.","Julgue os próximos itens, relativos ao contêiner Docker e à orquestração de contêineres em Kubernetes.","A respeito de desenvolvimento com containers, julgue o item seguinte.","Julgue os itens seguintes, relativos a virtualização e orquestração de infraestrutura.","Julgue os próximos itens, relativos ao DevOps.","Tendo em vista que, no atual cenário de desenvolvimento de aplicações web, é essencial considerar princípios, como consistência e escalabilidade, e práticas, como automação do processo de implantação e integração do código-fonte, julgue os itens subsequentes.","Acerca de conteinerização e de DevOps, julgue os itens subsequentes.","A respeito de conteinerização e DevOps, julgue os itens que se seguem.","Com base em arquitetura de TI, julgue os itens subsequentes.","Julgue os seguintes itens, relativos a containers de aplicação.","Julgue os itens a seguir, referentes ao conjunto de práticas de desenvolvimento de software, operação e de apoio envolvidas (DevOps).","Considere o seguinte conteúdo de um dockerfile.\n\nFROM rhel7:latest\nUSER root\nMAINTAINER Joao\nRUN yum -y install deltarpm yum-utils --\ndisablerepo=*-eus-* --disablerepo=*-htb-* *-\nsjis-*\\\n    --disablerepo=*-ha-* --disablerepo=*-rt-* --\ndisablerepo=*-lb-* --disablerepo=*-rs-* --\ndisablerepo=*-sap-*\nRUN yum-config-manager --disable *-eus-* *-htb-*\n*-ha-* *-rt-* *-lb-* *-rs-* *-sap-* *-sjis* >\n/dev/null\nRUN yum install httpd procps-ng MySQL-python -y\nADD action /var/www/cgi-bin/action\nRUN echo \"PassEnv DB_SERVICE_SERVICE_HOST\" >>\n/etc/httpd/conf/httpd.conf\nRUN chown root:apache /var/www/cgi-bin/action\nRUN chmod 755 /var/www/cgi-bin/action\nRUN echo \"Pagina Inicial\" >\n/var/www/html/index.html\nEXPOSE 80\nCMD mkdir /run/httpd ; /usr/sbin/httpd -D\nFOREGROUND\n\nTendo como referência essas informações, julgue os itens seguintes.","No que diz respeito a ferramentas de desenvolvimento, julgue os itens a seguir."],"questions":[{"id":"9f164804cda8","number":26,"stem":0,"statement":"Contêineres são instâncias de imagens do Docker que podem ser executadas usando o comando docker run.","answer":"C","source":{"slug":"TCE_RS_25","ano":2025},"explanation":{"verdict_reason":"A relação entre os dois objetos é de molde e instância: a imagem é estática e somente leitura, e cada execução dela produz um contêiner com camada gravável própria. O comando que faz essa passagem é o docker run, que cria e inicia o contêiner. O item enuncia exatamente essa relação.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"contêiner é instância em execução de uma imagem","citation":null,"trap_note":"Uma imagem gera N contêineres; um contêiner vem de uma imagem só. Item que inverta a cardinalidade — imagem criada a partir de contêineres em execução — está errado, salvo quando fala de docker commit."}},{"id":"9165de07055f","number":66,"stem":1,"statement":"Na situação apresentada, é necessário adicionar uma nova dependência à aplicação e, então, modificar diretamente a imagem Docker já criada.","answer":"E","source":{"slug":"MP_CE_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"Imagem é artefato imutável: suas camadas são somente leitura depois do build e nada dentro delas se edita no lugar. Acrescentar uma dependência significa alterar o Dockerfile (ou o arquivo de dependências que ele copia) e reconstruir a imagem, gerando nova etiqueta. O que muda em tempo de execução é a camada gravável do contêiner, que desaparece quando ele é removido.","distortion_type":"troca_de_termo","distorted_span":"modificar diretamente a imagem Docker já criada","corrected_statement":"Na situação apresentada, é necessário adicionar uma nova dependência à aplicação e, então, alterar o Dockerfile e reconstruir a imagem Docker.","concept":"imagem imutável: altera-se o Dockerfile e reconstrói-se","citation":null,"trap_note":"Tempo de construção × tempo de execução: Dockerfile e imagem pertencem ao primeiro e não mudam depois; contêiner e camada gravável pertencem ao segundo. Item que manda editar imagem pronta troca os dois tempos."}},{"id":"d322a0d4f54f","number":67,"stem":1,"statement":"A configuração de variáveis de ambiente específicas em um contêiner Docker utilizando o comando docker create permite que essas variáveis sejam definidas antes da inicialização do contêiner, o que garante maior controle sobre o ambiente de execução.","answer":"C","source":{"slug":"MP_CE_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"O docker create executa a primeira metade do que o docker run faz: resolve a imagem, cria a camada gravável e fixa a configuração do contêiner — inclusive as variáveis de ambiente passadas com -e — sem iniciar processo algum. O contêiner fica no estado created e só arranca com docker start. Por isso é correto dizer que as variáveis ficam definidas antes da inicialização.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"docker create configura sem iniciar","citation":null,"trap_note":"docker run = create + start. Com essa igualdade na cabeça, os itens que separam configurar de executar (create, start, exec, attach) se resolvem sem decorar cada comando."}},{"id":"bb3ef09ca3a0","number":68,"stem":2,"statement":"Para executar duas instâncias do PostgreSQL em contêineres separados, é correto utilizar os seguintes comandos, mapeando-se portas diferentes do host para a porta padrão do PostgreSQL (5432) no contêiner.\n\ndocker run -d -p 5433:5432 --name postgres_dev\npostgres\ndocker run -d -p 5434:5432 --name postgres_test\npostgres","answer":"C","source":{"slug":"MP_CE_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"Duas instâncias do mesmo serviço não colidem porque cada contêiner tem a própria pilha de rede: ambos podem escutar na 5432 internamente. O que não pode repetir é a porta do host, e é exatamente isso que os comandos resolvem ao publicar 5433 e 5434. Uma única imagem postgres origina quantos contêineres se quiser, cada um com nome e camada gravável próprios.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"uma imagem, muitos contêineres; a porta que precisa ser única é a do host","citation":null,"trap_note":"Em -p, leia sempre da esquerda para a direita: HOST:CONTÊINER. Repetir a porta da direita em contêineres diferentes é normal; repetir a da esquerda, com os dois no ar, é que quebra."}},{"id":"d3f27c23c3f4","number":69,"stem":2,"statement":"O Registry Access Management permite controlar quais registries os desenvolvedores podem acessar usando o Docker Desktop; esse recurso opera no nível de DNS e garante suporte a registries somente locais.","answer":"E","source":{"slug":"MP_CE_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"A primeira metade é verdadeira: o Registry Access Management é um controle administrativo do Docker Desktop e filtra por nome de domínio, no nível de DNS. O erro está no fecho. O recurso existe para autorizar registries remotos — Docker Hub, registries de terceiros, instalações da própria organização e espelhos —, e não para suportar apenas registries locais; como o filtro é por hostname, ele nem sequer alcança registry acessado por endereço IP.","distortion_type":"generalizacao","distorted_span":"garante suporte a registries somente locais","corrected_statement":"O Registry Access Management permite controlar quais registries os desenvolvedores podem acessar usando o Docker Desktop; esse recurso opera no nível de DNS e abrange registries em nuvem, locais e espelhos, desde que acessados por nome de domínio.","concept":"Registry Access Management: filtro por DNS, para registries permitidos em geral","citation":"Docker Docs — Registry Access Management","trap_note":"Metade verdadeira não salva item. Quando a banca liga duas afirmações com um ponto e vírgula ou um 'e', julgue cada uma sozinha: basta uma falsa para o item inteiro ser errado."}},{"id":"197d90c91ec9","number":70,"stem":2,"statement":"No trecho de código a seguir, a opção -p mapeia uma porta específica do host para uma porta correspondente no contêiner, o que permite o acesso aos serviços em execução dentro do contêiner a partir do host.\n\ndocker run -d -p HOST_PORT:CONTAINER_PORT\npostgres","answer":"C","source":{"slug":"MP_CE_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"Por padrão a porta em que o processo escuta dentro do contêiner não é alcançável do hospedeiro, porque o contêiner tem pilha de rede própria. A opção -p publica a porta, criando o encaminhamento HOST_PORT:CONTAINER_PORT descrito no item. Sem -p (ou -P), o serviço sobe e roda, mas ninguém de fora da rede do Docker chega a ele.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"-p publica a porta do contêiner no host","citation":null,"trap_note":"Publicar é diferente de expor: EXPOSE, no Dockerfile, apenas documenta a porta de escuta; quem abre o caminho a partir do host é -p ou -P, na execução."}},{"id":"7b1b1e073b0d","number":56,"stem":3,"statement":"Imagem de contêiner no Kubernetes é uma representação em formato binário que engloba uma aplicação e suas dependências, pronta para ser executada em um contêiner.","answer":"C","source":{"slug":"MP_TO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"Imagem é o artefato empacotado: um conjunto de camadas somente leitura, distribuído em formato binário, com a aplicação, suas dependências e os metadados de execução. Ela é estática e serve de molde; a instância em execução é o contêiner. A definição do item corresponde a isso.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"imagem é o molde empacotado; contêiner é a instância","citation":null,"trap_note":"Imagem × contêiner é classe × objeto. Tudo o que for estático, versionado, etiquetado e enviado a registry é imagem; tudo o que tiver estado, PID, IP e ciclo de vida é contêiner."}},{"id":"ff068431cbc5","number":56,"stem":4,"statement":"Para otimizar o tamanho de uma imagem com o uso do Kubernetes, suas camadas são ordenadas da mais provável de ser alterada para a menos provável de ser alterada, a fim de diminuir o tamanho da imagem para envio e recepção.","answer":"E","source":{"slug":"MPO_24","ano":2024},"explanation":{"verdict_reason":"A regra de ordenação é a oposta: põe-se primeiro o que muda menos (imagem base, instalação de dependências) e por último o que muda mais (o código), para que o cache reaproveite as camadas iniciais e só as finais precisem ser reconstruídas e transferidas. Some-se que quem constrói imagem é o Docker, a partir do Dockerfile; o Kubernetes apenas executa imagens prontas.","distortion_type":"inversao","distorted_span":"da mais provável de ser alterada para a menos provável de ser alterada","corrected_statement":"Para otimizar o tamanho de uma imagem, suas camadas são ordenadas da menos provável de ser alterada para a mais provável de ser alterada, a fim de diminuir o tamanho da imagem para envio e recepção.","concept":"ordem das camadas: o estável primeiro, o volátil por último","citation":null,"trap_note":"Cache de camada é invalidado a partir da primeira instrução alterada, e todas as seguintes caem junto. Daí a ordem: quanto mais cedo a camada, mais estável ela precisa ser."}},{"id":"c2480f2faaac","number":57,"stem":4,"statement":"Um nó master do Kubernetes, composto por um ou mais workloads, é responsável por executar os contêineres em estruturas de pods.","answer":"E","source":{"slug":"MPO_24","ano":2024},"explanation":{"verdict_reason":"O nó master hospeda o plano de controle, que decide: agenda, guarda o estado e reconcilia. Quem executa contêineres dentro de pods é o nó de trabalho, por meio do kubelet e do runtime. O item ainda descreve o master como composto por workloads, quando a hierarquia é a inversa — o nó hospeda pods e o pod hospeda contêineres.","distortion_type":"inversao","distorted_span":"nó master do Kubernetes, composto por um ou mais workloads, é responsável por executar os contêineres","corrected_statement":"Um nó de trabalho do Kubernetes, composto por um ou mais pods, é responsável por executar os contêineres em estruturas de pods.","concept":"master decide, worker executa","citation":null,"trap_note":"Monte a cadeia antes de ler: cluster contém nó, nó executa pod, pod contém contêiner; plano de controle manda no kubelet, kubelet manda no runtime. Qualquer seta apontando para cima está errada."}},{"id":"ca7a26db7b84","number":58,"stem":3,"statement":"O comando a seguir clona o repositório especificado e o utiliza como contexto para criar uma imagem Docker de acordo com as instruções contidas no Dockerfile localizado na raiz desse repositório. docker build github.com/creack/docker-firefox","answer":"C","source":{"slug":"MP_TO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"Além de um diretório local, o docker build aceita como contexto a URL de um repositório Git: ele clona o repositório, usa o clone como contexto e procura o Dockerfile na raiz, salvo indicação em contrário com -f. É o que o comando apresentado faz. O que ele não faz é executar a imagem — build apenas constrói.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"contexto de build pode ser um repositório Git remoto","citation":"Docker Docs — docker build (build context)","trap_note":"O último argumento do docker build é sempre o contexto, não o Dockerfile. Diretório, URL de Git ou tarball servem; o Dockerfile dentro dele é escolhido por -f."}},{"id":"fb75c9aa14bd","number":58,"stem":4,"statement":"O Docker utiliza sistemas de arquivos chamados de build, voltados para otimizar o uso, a transferência e o armazenamento de imagens, contêineres e volumes.","answer":"E","source":{"slug":"MPO_24","ano":2024},"explanation":{"verdict_reason":"O que otimiza uso, transferência e armazenamento de imagens, contêineres e volumes são os sistemas de arquivos em união (union file systems) e seus drivers de armazenamento, como o overlay2, que empilham camadas somente leitura e aplicam cópia na escrita. Build não é nome de sistema de arquivos: é a etapa que produz a imagem. O resto da frase está correto.","distortion_type":"troca_de_termo","distorted_span":"sistemas de arquivos chamados de build","corrected_statement":"O Docker utiliza sistemas de arquivos em união (union file systems), voltados para otimizar o uso, a transferência e o armazenamento de imagens, contêineres e volumes.","concept":"union file system e overlay2 sustentam as camadas","citation":"Docker Docs — Storage drivers","trap_note":"Quando o item define uma tecnologia por um nome, verifique se o nome é de coisa existente. Aqui todo o predicado está certo e só o sujeito foi substituído — é a troca de termo em estado puro."}},{"id":"95666d7b69aa","number":59,"stem":3,"statement":"No comando a seguir, o arquivo compose.yml especifica as configurações ou personalizações adicionais a serem utilizadas para orquestrar o serviço Docker.\n\ndocker compose -f compose.yml -f\ncompose.admin.yml","answer":"E","source":{"slug":"MP_TO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"Com vários -f, a ordem decide o papel de cada arquivo: o primeiro é a base e os seguintes acrescentam ou sobrescrevem configuração, na sequência em que aparecem. No comando, a base é o compose.yml e quem traz as personalizações adicionais é o compose.admin.yml. O item troca os dois papéis.","distortion_type":"inversao","distorted_span":"o arquivo compose.yml especifica as configurações ou personalizações adicionais","corrected_statement":"No comando a seguir, o arquivo compose.admin.yml especifica as configurações ou personalizações adicionais a serem utilizadas para orquestrar o serviço Docker.","concept":"primeiro -f é a base; os seguintes sobrepõem","citation":"Docker Docs — Merge Compose files","trap_note":"Onde houver ordem, a banca a inverte. Vale para -f do Compose, para camadas do Dockerfile e para a sequência de arquivos de configuração em geral: quem vem depois vence."}},{"id":"b4f9b9389ebb","number":78,"stem":5,"statement":"Processos executados em containers nos mesmos namespaces são invisíveis entre si — um não tem conhecimento dos demais — e executados de forma isolada.","answer":"E","source":{"slug":"MPO_24","ano":2024},"explanation":{"verdict_reason":"O namespace é o mecanismo que isola, e ele isola quem está fora dele: processos no MESMO namespace de PID se enxergam normalmente; invisíveis entre si são os processos em namespaces distintos. O item usa a condição certa para concluir o contrário. É por compartilharem namespace, aliás, que contêineres de um mesmo pod conversam por localhost.","distortion_type":"inversao","distorted_span":"nos mesmos namespaces são invisíveis entre si","corrected_statement":"Processos executados em containers em namespaces distintos são invisíveis entre si — um não tem conhecimento dos demais — e executados de forma isolada.","concept":"mesmo namespace, visibilidade; namespaces diferentes, isolamento","citation":null,"trap_note":"Namespace isola visão (PID, rede, montagens, usuários); cgroup limita consumo (CPU, memória, E/S). Item que atribua limite de recurso a namespace, ou isolamento de visão a cgroup, trocou os dois."}},{"id":"d8f18171b3a3","number":91,"stem":6,"statement":"No dockerfile mostrado a seguir, com a execução do comando RUN pip install -r requirements.txt, serão instaladas as dependências listadas no requirements.txt, sem o armazenamento de caches, o que ajuda a reduzir o tamanho final da imagem.\n\nFROM python:3.12\nWORKDIR /usr/local/app\nCOPY requirements.txt ./\nRUN pip install -r requirements.txt\nCOPY src ./src\nEXPOSE 5000\nRUN useradd app\nUSER app\nCMD [\"uvicorn\", \"app.main:app\", \"--host\",\n\"0.0.0.0\", \"--port\", \"8080\"]\"0.0.0.0\", \"--\nport\", \"8080\"]","answer":"E","source":{"slug":"TRT10_24","ano":2024},"explanation":{"verdict_reason":"O pip guarda em cache os pacotes que baixa, e esse cache é gravado dentro da camada criada pelo RUN, aumentando a imagem final. Para não armazená-lo é preciso pedir explicitamente — pip install --no-cache-dir — ou apagá-lo no mesmo RUN. Como o Dockerfile mostrado não traz nenhuma das duas coisas, as dependências entram com o cache junto e a redução alegada não acontece.","distortion_type":"relacao_causal","distorted_span":"sem o armazenamento de caches","corrected_statement":"No dockerfile mostrado a seguir, com a execução do comando RUN pip install -r requirements.txt, serão instaladas as dependências listadas no requirements.txt, com o armazenamento de caches, o que aumenta o tamanho final da imagem.","concept":"cache do pip permanece na camada sem --no-cache-dir","citation":null,"trap_note":"Em item com código, procure no comando a opção que produziria o efeito anunciado. Efeito afirmado sem a opção correspondente é causa inventada, e o código mostrado é a prova."}},{"id":"d536fb0b7bde","number":111,"stem":7,"statement":"Registry Docker é uma ferramenta que favorece a definição e a execução de aplicativos nos contêineres a partir do controle do que será executado pelos aplicativos; para isso, utiliza um único arquivo de configuração YAML, o qual permite iniciar os serviços gerenciados pelo arquivo.","answer":"E","source":{"slug":"SEPLAG_CE_24","ano":2024},"explanation":{"verdict_reason":"A descrição — definir e executar uma aplicação de vários contêineres a partir de um único arquivo YAML, subindo os serviços declarados nele — é do Docker Compose. O registry é outra coisa: o serviço que armazena e distribui imagens, de onde se faz pull e para onde se faz push. Trocou-se apenas o nome da ferramenta; o restante descreve fielmente o Compose.","distortion_type":"troca_de_termo","distorted_span":"Registry Docker é uma ferramenta que favorece a definição e a execução de aplicativos nos contêineres","corrected_statement":"Docker Compose é uma ferramenta que favorece a definição e a execução de aplicativos nos contêineres a partir do controle do que será executado pelos aplicativos; para isso, utiliza um único arquivo de configuração YAML, o qual permite iniciar os serviços gerenciados pelo arquivo.","concept":"registry guarda e distribui imagens; Compose orquestra serviços","citation":null,"trap_note":"Se o item menciona arquivo YAML único e serviços, está falando de Compose, qualquer que seja o nome no sujeito. Registry só aparece legitimamente em pull, push, tag e autenticação."}},{"id":"a4a67f22661a","number":114,"stem":7,"statement":"Os contêineres são padronizáveis, o que permite a inclusão das dependências necessárias para sua execução, na qual, por exemplo, cada nó em um cluster Kubernetes executa os contêineres.","answer":"C","source":{"slug":"SEPLAG_CE_24","ano":2024},"explanation":{"verdict_reason":"A padronização é o ponto do contêiner: a imagem já inclui as dependências, de modo que o mesmo artefato executa igual em qualquer lugar que tenha um runtime compatível. Em um cluster Kubernetes, cabe a cada nó executar os contêineres que lhe forem atribuídos — o plano de controle decide onde, o kubelet e o runtime do nó fazem rodar.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"contêiner padronizado; quem executa é o nó","citation":null,"trap_note":"Itens que dizem que o nó executa contêineres costumam estar certos; os que dizem que o plano de controle os executa, errados. Decidir e executar ficam em metades diferentes do cluster."}},{"id":"87f4f69bcd17","number":76,"stem":8,"statement":"Um exemplo prático de conteinerização de aplicação é a utilização do Docker para criar um ambiente consistente; nesse caso, é correto criar um arquivo Dockerfile por meio do comando docker build.","answer":"E","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"O Dockerfile é entrada, não saída: quem o escreve é a pessoa, e o docker build o lê para produzir uma imagem. O item inverte o sentido da seta — o build consome o Dockerfile, jamais o cria. A ideia geral de usar contêiner para obter ambiente consistente está certa; o mecanismo citado está de cabeça para baixo.","distortion_type":"inversao","distorted_span":"criar um arquivo Dockerfile por meio do comando docker build","corrected_statement":"Um exemplo prático de conteinerização de aplicação é a utilização do Docker para criar um ambiente consistente; nesse caso, é correto criar um arquivo Dockerfile e, a partir dele, gerar a imagem por meio do comando docker build.","concept":"Dockerfile alimenta o build; a saída é a imagem","citation":null,"trap_note":"Fixe a cadeia Dockerfile → imagem → contêiner e confira a direção de cada item. Comando que produza a etapa anterior à sua entrada está errado."}},{"id":"938ea256ca08","number":77,"stem":8,"statement":"A adoção de tecnologias de conteinerização, como o Docker, permite à equipe orquestrar vários contêineres em conjunto, por exemplo, um contêiner para a aplicação Node.js e outro, para o banco de dados MongoDB.","answer":"C","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"O padrão da conteinerização é um processo principal por contêiner, e a aplicação se compõe juntando contêineres: um para o Node.js, outro para o MongoDB, ligados por rede. Orquestrar é coordenar esse conjunto — subida, ordem, rede, escala —, com Compose em uma máquina ou com Kubernetes em um cluster. O item descreve exatamente esse uso.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"um processo por contêiner; a aplicação é o conjunto orquestrado","citation":null,"trap_note":"Aplicação e banco em contêineres separados é a resposta esperada. Item que exija empilhar aplicação e banco no mesmo contêiner para que conversem está errado: eles conversam pela rede do Docker, por nome de serviço."}},{"id":"c77dac314d27","number":105,"stem":9,"statement":"A conteinerização permite que desenvolvedores criem uma aplicação e façam sua implantação em vários sistemas operacionais sem a necessidade de reescrever código para adaptá-la.","answer":"C","source":{"slug":"CNPQ_23","ano":2023},"explanation":{"verdict_reason":"A imagem carrega a aplicação com todas as dependências de que ela precisa, de modo que o mesmo artefato é implantado onde houver um mecanismo de contêiner compatível. O item mede a portabilidade do ponto de vista de quem desenvolve: não se reescreve código para cada ambiente de destino. É essa promessa — empacotar uma vez, executar em qualquer lugar — que define a conteinerização.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"portabilidade: empacota-se uma vez e implanta-se sem adaptar código","citation":null,"trap_note":"Portabilidade aqui é da aplicação, não do núcleo. Quando o item descer ao núcleo — imagem Linux executando sobre núcleo Windows sem camada nenhuma no meio —, a resposta muda, porque o contêiner usa o núcleo do hospedeiro."}},{"id":"c397edc79e28","number":112,"stem":10,"statement":"A comunicação entre os servidores docker e os repositórios de registros deve ocorrer com uso de chaves criptográficas, para garantir a confidencialidade das informações.","answer":"C","source":{"slug":"CAPES_23","ano":2023},"explanation":{"verdict_reason":"O acesso a um registry é tráfego HTTP, e o Docker exige TLS para falar com ele: um registry sem TLS só é aceito se for declarado inseguro na configuração do daemon, o que é exceção e não regra. TLS se apoia em par de chaves e certificado, e é o que protege credenciais e conteúdo das imagens em trânsito. Daí ser correto exigir chaves criptográficas nessa comunicação.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"comunicação com o registry por TLS","citation":null,"trap_note":"Registry é a fronteira externa do Docker: é por ali que a imagem entra no ambiente. Toda afirmação sobre cifrar o transporte, autenticar o cliente ou assinar e verificar imagem tende a ser correta."}},{"id":"03e2cf0687fd","number":57,"stem":11,"statement":"Contêineres Docker encapsulam em um mesmo objeto a aplicação e o seu ambiente de execução (sistema operacional e demais dependências), aproximando os times de desenvolvimento e de operação.","answer":"C","source":{"slug":"PGE_RJ_22","ano":2022},"explanation":{"verdict_reason":"A imagem empacota a aplicação junto com o ambiente de que ela precisa para rodar: bibliotecas, binários e os arquivos de sistema da distribuição. É esse pacote único que elimina o descompasso entre a máquina do desenvolvedor e a produção e, por isso, aproxima desenvolvimento e operação. O que a imagem não traz é o núcleo, compartilhado com o hospedeiro — mas o item fala do ambiente de execução, não do núcleo.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"o contêiner leva a aplicação e seu ambiente de execução","citation":null,"trap_note":"Separe ambiente de execução de núcleo. Dizer que o contêiner carrega o ambiente de execução está certo; dizer que ele carrega um sistema operacional convidado completo, com núcleo próprio, está errado — esse é o modelo da máquina virtual."}},{"id":"b9fa35f421fb","number":116,"stem":12,"statement":"Quando se executa um container de aplicação .NET, o sistema operacional (SO) contido no convidado, ou seja, sob o SO host, com acesso ao hardware subjacente.","answer":"E","source":{"slug":"BANCO_DO_NORDESTE_22","ano":2022},"explanation":{"verdict_reason":"Quem tem sistema operacional convidado sobre um hipervisor, com acesso mediado ao hardware, é a máquina virtual. O contêiner não tem convidado algum: compartilha o núcleo do hospedeiro e é isolado por namespaces e cgroups, sem falar com o hardware diretamente. Uma aplicação .NET em contêiner leva o runtime e as bibliotecas, não um sistema operacional inteiro.","distortion_type":"atribuicao_errada","distorted_span":"o sistema operacional (SO) contido no convidado","corrected_statement":"Quando se executa um container de aplicação .NET, não há sistema operacional convidado: o container compartilha o núcleo do SO host e é isolado por namespaces e cgroups, sem acesso direto ao hardware subjacente.","concept":"contêiner × máquina virtual: núcleo compartilhado, sem SO convidado","citation":null,"trap_note":"Ouviu convidado, hipervisor ou acesso ao hardware? É vocabulário de máquina virtual. Contêiner responde por núcleo compartilhado, namespaces, cgroups e virtualização em nível de sistema operacional."}},{"id":"49f380d1a84c","number":118,"stem":12,"statement":"Caso seja necessário informar ao Docker que um container deve escutar na porta de rede 80 do TCP, o comando correto no DockerFile é o seguinte. EXPOSE 80/tcp","answer":"C","source":{"slug":"BANCO_DO_NORDESTE_22","ano":2022},"explanation":{"verdict_reason":"EXPOSE é a instrução do Dockerfile que informa em que porta e em que protocolo o contêiner escuta, na forma EXPOSE porta/protocolo, com tcp como padrão — logo, EXPOSE 80/tcp é a escrita correta para o que se pediu. Repare no limite dessa instrução: ela documenta e serve de metadado, mas não abre a porta para o hospedeiro, o que só acontece com -p ou -P na execução.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"EXPOSE declara a porta de escuta do contêiner","citation":"Docker Docs — Dockerfile reference (EXPOSE)","trap_note":"EXPOSE documenta, -p publica. Item que diga que EXPOSE torna o serviço acessível a partir do host está errado; item que diga que EXPOSE apenas informa a porta está certo."}},{"id":"6e98634417d6","number":119,"stem":12,"statement":"Para construir uma imagem e fazer o deploy de Dockerfile example-java-df, o comando correto é o seguinte. docker commit -f example-java-df","answer":"E","source":{"slug":"BANCO_DO_NORDESTE_22","ano":2022},"explanation":{"verdict_reason":"O docker commit não constrói a partir de Dockerfile: ele congela o estado atual de um contêiner em uma nova imagem. Construir com um Dockerfile de nome fora do padrão é docker build -f example-java-df, seguido do contexto. E a implantação é um terceiro passo, de push e execução — o comando citado não faz nenhuma das duas coisas.","distortion_type":"troca_de_termo","distorted_span":"docker commit -f example-java-df","corrected_statement":"Para construir uma imagem de Dockerfile example-java-df, o comando correto é o seguinte. docker build -f example-java-df .","concept":"build lê Dockerfile; commit fotografa contêiner","citation":null,"trap_note":"A opção -f existe em vários comandos com sentidos diferentes (arquivo no build e no compose, força no rm). Confira primeiro o verbo, depois a opção: verbo errado invalida o item por inteiro."}},{"id":"9c4bba9de9c3","number":120,"stem":12,"statement":"Considere o seguinte Dockerfile para uma aplicação .NET.\n\nFROM mcr.microsoft.com/dotnet/aspnet:6.0\nWORKDIR /App\nCOPY --from=build-env /App/out .\nENTRYPOINT [“dotnet”, “DotNet.Docker.dll”]\n\nNesse caso, o comando ENTRYPOINT solicita ao Docker que configure o executável; desse modo, quando o container é iniciado, esse comando ENTRYPOINT é executado.","answer":"C","source":{"slug":"BANCO_DO_NORDESTE_22","ano":2022},"explanation":{"verdict_reason":"ENTRYPOINT define o executável do contêiner: o processo que o Docker dispara quando o contêiner inicia, aqui na forma exec, com o binário dotnet e a DLL como argumento. É o que o item afirma. A diferença para o CMD é que este fornece comando ou argumentos padrão, substituíveis pelo que se escreve no docker run, ao passo que o ENTRYPOINT permanece e recebe esses argumentos.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"ENTRYPOINT fixa o executável; CMD dá o padrão substituível","citation":"Docker Docs — Dockerfile reference (ENTRYPOINT)","trap_note":"CMD × ENTRYPOINT em uma frase: o argumento passado no docker run substitui o CMD e é anexado ao ENTRYPOINT. Guardada essa frase, todo item do par se decide."}},{"id":"346b050ca3bd","number":85,"stem":13,"statement":"As alterações efetuadas em arquivos e diretórios copiados de uma camada base para dentro de um container docker, por padrão, são vistas pelos múltiplos containers do mesmo sistema de arquivos.","answer":"E","source":{"slug":"SEFAZ_CE_21","ano":2021},"explanation":{"verdict_reason":"Cada contêiner recebe a própria camada gravável sobre as camadas somente leitura da imagem. Na primeira escrita, o arquivo é copiado da camada de baixo para essa camada — a cópia na escrita — e a alteração passa a existir apenas naquele contêiner; os demais continuam enxergando a versão original. É justamente por isso que vários contêineres compartilham a mesma imagem sem misturar dados.","distortion_type":"inversao","distorted_span":"são vistas pelos múltiplos containers do mesmo sistema de arquivos","corrected_statement":"As alterações efetuadas em arquivos e diretórios copiados de uma camada base para dentro de um container docker, por padrão, são vistas somente pelo container que as efetuou.","concept":"cópia na escrita: a camada gravável é privada de cada contêiner","citation":"Docker Docs — Storage drivers (copy-on-write)","trap_note":"Compartilhado é o que é somente leitura; privado é o que é gravável. Compartilhar escrita entre contêineres exige volume, e volume precisa ser declarado — não acontece por padrão."}},{"id":"9fa35b51636c","number":86,"stem":14,"statement":"O comando a seguir é capaz de fazer o build e iniciar a execução do container, respectivamente. docker run -d -p 80:80 –name=Dockerfile","answer":"E","source":{"slug":"SERPRO_21","ano":2021},"explanation":{"verdict_reason":"Um docker run não constrói nada: ele cria e inicia um contêiner a partir de uma imagem que já existe. Construir é docker build, que lê o Dockerfile. E o parâmetro de nome batiza o contêiner — escrever ali a palavra Dockerfile não indica arquivo algum ao Docker, já que o arquivo de construção se informa com -f, no build.","distortion_type":"troca_de_termo","distorted_span":"é capaz de fazer o build e iniciar a execução do container","corrected_statement":"O comando a seguir é capaz de iniciar a execução do container a partir de uma imagem existente, mas não de fazer o build, que exige o comando docker build.","concept":"docker build constrói; docker run executa","citation":null,"trap_note":"Leia o verbo do comando antes de aceitar o efeito anunciado. build constrói, run cria e inicia, start religa, exec entra, commit fotografa, push envia."}},{"id":"d7d39d02dd87","number":111,"stem":15,"statement":"O Docker é uma ferramenta open source que permite a criação de ambientes virtuais por meio de Linux Containers, sendo uma das vantagens dos contêineres Docker fornecer uma virtualização em nível de sistema operacional, o que isola as aplicações em execução e não utiliza tantos recursos da máquina quanto as máquinas virtuais.","answer":"C","source":{"slug":"SLU_DF_19","ano":2019},"explanation":{"verdict_reason":"Virtualização em nível de sistema operacional é precisamente o modelo do contêiner: um único núcleo servindo a várias instâncias isoladas por namespaces e cgroups — os Linux Containers sobre os quais o Docker foi construído. Como não há hipervisor nem sistema convidado por instância, gasta-se menos memória e disco e a partida é mais rápida que a de uma máquina virtual. E o motor do Docker é software de código aberto.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"virtualização em nível de SO consome menos que virtualização de hardware","citation":null,"trap_note":"Contêiner ganha em densidade e tempo de partida; máquina virtual ganha em isolamento, porque tem núcleo próprio. Item que dê ao contêiner isolamento maior que o da máquina virtual inverte a troca."}}]}