Tutorial: Colocar um aplicativo .NET Core em contêineresTutorial: Containerize a .NET Core app

Neste tutorial, você aprenderá a colocar em contêiner um aplicativo .NET Core com o Docker.In this tutorial, you'll learn how to containerize a .NET Core application with Docker. Os contêineres têm muitos recursos e benefícios, como uma infraestrutura imutável, fornecendo uma arquitetura portátil e habilitando a escalabilidade.Containers have many features and benefits, such as being an immutable infrastructure, providing a portable architecture, and enabling scalability. A imagem pode ser usada para criar contêineres para seu ambiente de desenvolvimento local, nuvem privada ou nuvem pública.The image can be used to create containers for your local development environment, private cloud, or public cloud.

Neste tutorial, você:In this tutorial, you:

  • Criar e publicar um aplicativo .NET Core simplesCreate and publish a simple .NET Core app
  • Criar e configurar um Dockerfile para .NET CoreCreate and configure a Dockerfile for .NET Core
  • Compilar uma imagem do dockerBuild a Docker image
  • Criar e executar um contêiner do DockerCreate and run a Docker container

Você aprenderá as tarefas de build e implantação de contêiner do Docker para um aplicativo .NET Core.You'll understand the Docker container build and deploy tasks for a .NET Core application. A plataforma Docker usa o Mecanismo do Docker para criar e empacotar aplicativos como imagens do Docker com agilidade.The Docker platform uses the Docker engine to quickly build and package apps as Docker images. Essas imagens são gravadas no formato Dockerfile para serem implantadas e executadas em um contêiner em camadas.These images are written in the Dockerfile format to be deployed and run in a layered container.

Observação

Este tutorial não é para aplicativos ASP.NET Core.This tutorial is not for ASP.NET Core apps. Se você estiver usando ASP.NET Core, consulte o tutorial saiba como colocar um aplicativo em contêineres de ASP.NET Core .If you're using ASP.NET Core, see the Learn how to containerize an ASP.NET Core application tutorial.

Pré-requisitosPrerequisites

Instale os seguintes pré-requisitos:Install the following prerequisites:

  • SDK do .NET Core 3,1.NET Core 3.1 SDK
    Se você tiver o .NET Core instalado, use o comando dotnet --info para determinar qual SDK está usando.If you have .NET Core installed, use the dotnet --info command to determine which SDK you're using.
  • Docking Community EditionDocker Community Edition
  • Uma pasta de trabalho temporária para o Dockerfile e o aplicativo de exemplo do .NET Core.A temporary working folder for the Dockerfile and .NET Core example app. Neste tutorial, o nome Docker – Working é usado como a pasta de trabalho.In this tutorial, the name docker-working is used as the working folder.

Criar aplicativo .NET CoreCreate .NET Core app

Você precisa de um aplicativo .NET Core que o contêiner do Docker irá executar.You need a .NET Core app that the Docker container will run. Abra seu terminal, crie uma pasta de trabalho se você ainda não fez isso e entre nela.Open your terminal, create a working folder if you haven't already, and enter it. Na pasta de trabalho, execute o seguinte comando para criar um novo projeto em um subdiretório chamado app:In the working folder, run the following command to create a new project in a subdirectory named app:

dotnet new console -o App -n NetCore.Docker

A árvore de pastas terá aparência semelhante à seguinte:Your folder tree will look like the following:

docker-working
    └──App
        ├──NetCore.Docker.csproj
        ├──Program.cs
        └──obj
            ├──NetCore.Docker.csproj.nuget.dgspec.json
            ├──NetCore.Docker.csproj.nuget.g.props
            ├──NetCore.Docker.csproj.nuget.g.targets
            ├──project.assets.json
            └──project.nuget.cache

O dotnet new comando cria uma nova pasta chamada app e gera um aplicativo de console "Olá, mundo".The dotnet new command creates a new folder named App and generates a "Hello World" console application. Altere os diretórios e navegue até a pasta do aplicativo de sua sessão de terminal.Change directories and navigate into the App folder, from your terminal session. Use o dotnet run comando para iniciar o aplicativo.Use the dotnet run command to start the app. O aplicativo será executado e imprimirá Hello World! abaixo do comando:The application will run, and print Hello World! below the command:

dotnet run
Hello World!

O modelo padrão cria um aplicativo que é impresso no terminal e, em seguida, termina imediatamente.The default template creates an app that prints to the terminal and then immediately terminates. Neste tutorial, você usará um aplicativo que faz um loop indefinidamente.For this tutorial, you'll use an app that loops indefinitely. Abra o arquivo Program.cs em um editor de texto.Open the Program.cs file in a text editor.

Dica

Se você estiver usando Visual Studio Code, na sessão de terminal anterior, digite o seguinte comando:If you're using Visual Studio Code, from the previous terminal session type the following command:

code .

Isso abrirá a pasta do aplicativo que contém o projeto no Visual Studio Code.This will open the App folder that contains the project in Visual Studio Code.

O Program.cs deve ser semelhante ao seguinte código C#:The Program.cs should look like the following C# code:

using System;

namespace NetCore.Docker
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Substitua o arquivo pelo seguinte código que conta os números a cada segundo:Replace the file with the following code that counts numbers every second:

using System;
using System.Threading.Tasks;

namespace NetCore.Docker
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var counter = 0;
            var max = args.Length != 0 ? Convert.ToInt32(args[0]) : -1;
            while (max == -1 || counter < max)
            {
                Console.WriteLine($"Counter: {++counter}");
                await Task.Delay(1000);
            }
        }
    }
}

Salve o arquivo e teste o programa novamente com dotnet run.Save the file and test the program again with dotnet run. Lembre-se de que esse aplicativo é executado indefinidamente.Remember that this app runs indefinitely. Use o comando Cancel Ctrl + C para interrompê-lo.Use the cancel command Ctrl+C to stop it. Veja a seguir um exemplo de saída:The following is an example output:

dotnet run
Counter: 1
Counter: 2
Counter: 3
Counter: 4
^C

Se você passar um número na linha de comando para o aplicativo, ele apenas contará até tal valor e, em seguida, sairá.If you pass a number on the command line to the app, it will only count up to that amount and then exit. Experimente com dotnet run -- 5 para contar até cinco.Try it with dotnet run -- 5 to count to five.

Importante

Quaisquer parâmetros após -- não são passados para o comando dotnet run e, em vez disso, são passados para o aplicativo.Any parameters after -- are not passed to the dotnet run command and instead are passed to your application.

Publicar um aplicativo .NET CorePublish .NET Core app

Antes de adicionar o aplicativo .NET Core à imagem do Docker, primeiro ele deve ser publicado.Before adding the .NET Core app to the Docker image, first it must be published. É melhor fazer com que o contêiner execute a versão publicada do aplicativo.It is best to have the container run the published version of the app. Para publicar o aplicativo, execute o seguinte comando:To publish the app, run the following command:

dotnet publish -c Release

Esse comando compila seu aplicativo para a pasta publish.This command compiles your app to the publish folder. O caminho para a pasta publish da pasta de trabalho deve ser .\App\bin\Release\netcoreapp3.1\publish\The path to the publish folder from the working folder should be .\App\bin\Release\netcoreapp3.1\publish\

Na pasta do aplicativo , obtenha uma listagem de diretório da pasta de publicação para verificar se o arquivo de NetCore.Docker.dll foi criado.From the App folder, get a directory listing of the publish folder to verify that the NetCore.Docker.dll file was created.

dir .\bin\Release\netcoreapp3.1\publish\

    Directory: C:\Users\dapine\App\bin\Release\netcoreapp3.1\publish

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        4/27/2020   8:27 AM            434 NetCore.Docker.deps.json
-a----        4/27/2020   8:27 AM           6144 NetCore.Docker.dll
-a----        4/27/2020   8:27 AM         171520 NetCore.Docker.exe
-a----        4/27/2020   8:27 AM            860 NetCore.Docker.pdb
-a----        4/27/2020   8:27 AM            154 NetCore.Docker.runtimeconfig.json

Criar o DockerfileCreate the Dockerfile

O arquivo Dockerfile é usado pelo comando docker build para criar uma imagem de contêiner.The Dockerfile file is used by the docker build command to create a container image. Esse arquivo é um arquivo de texto chamado Dockerfile que não tem uma extensão.This file is a text file named Dockerfile that doesn't have an extension.

Crie um arquivo chamado Dockerfile no diretório que contém o . csproj e abra-o em um editor de texto.Create a file named Dockerfile in directory containing the .csproj and open it in a text editor. Este tutorial usará a imagem do ASP.NET Core Runtime (que contém a imagem do tempo de execução do .NET Core) e corresponde ao aplicativo de console do .NET Core.This tutorial will use the ASP.NET Core runtime image (which contains the .NET Core runtime image) and corresponds with the .NET Core console application.

FROM mcr.microsoft.com/dotnet/aspnet:3.1

Observação

A imagem de tempo de execução ASP.NET Core é usada intencionalmente aqui, embora a mcr.microsoft.com/dotnet/runtime:3.1 imagem possa ter sido usada.The ASP.NET Core runtime image is used intentionally here, although the mcr.microsoft.com/dotnet/runtime:3.1 image could have been used.

A FROM palavra-chave requer um nome de imagem de contêiner do Docker totalmente qualificado.The FROM keyword requires a fully qualified Docker container image name. O registro de contêiner da Microsoft (MCR, mcr.microsoft.com) é uma agregação do Hub do Docker, que hospeda contêineres publicamente acessíveis.The Microsoft Container Registry (MCR, mcr.microsoft.com) is a syndicate of Docker Hub - which hosts publicly accessible containers. O dotnet/core segmento é o repositório de contêiner, onde o aspnet segmento é o nome da imagem de contêiner.The dotnet/core segment is the container repository, where as the aspnet segment is the container image name. A imagem é marcada com 3.1 , que é usada para controle de versão.The image is tagged with 3.1, which is used for versioning. Portanto, mcr.microsoft.com/dotnet/aspnet:3.1 é o tempo de execução do .NET Core 3,1.Thus, mcr.microsoft.com/dotnet/aspnet:3.1 is the .NET Core 3.1 runtime. Certifique-se de extrair a versão de tempo de execução que corresponde ao tempo de execução direcionado pelo seu SDK.Make sure that you pull the runtime version that matches the runtime targeted by your SDK. Por exemplo, o aplicativo criado na seção anterior usava o SDK do .NET Core 3,1 e a imagem base mencionada no Dockerfile é marcada com 3,1.For example, the app created in the previous section used the .NET Core 3.1 SDK and the base image referred to in the Dockerfile is tagged with 3.1.

Salve o arquivo Dockerfile.Save the Dockerfile file. A estrutura de diretório da pasta de trabalho deve ser semelhante à mostrada a seguir.The directory structure of the working folder should look like the following. Alguns arquivos e pastas de nível mais profundo foram omitidos para economizar espaço no artigo:Some of the deeper-level files and folders have been omitted to save space in the article:

docker-working
    └──App
        ├──Dockerfile
        ├──NetCore.Docker.csproj
        ├──Program.cs
        ├──bin
        │   └──Release
        │       └──netcoreapp3.1
        │           └──publish
        │               ├──NetCore.Docker.deps.json
        │               ├──NetCore.Docker.exe
        │               ├──NetCore.Docker.dll
        │               ├──NetCore.Docker.pdb
        │               └──NetCore.Docker.runtimeconfig.json
        └──obj
            └──...

Do terminal, execute o seguinte comando:From your terminal, run the following command:

docker build -t counter-image -f Dockerfile .

O Docker processará cada linha no Dockerfile.Docker will process each line in the Dockerfile. O . no comando docker build instrui o Docker a usar a pasta atual para encontrar um Dockerfile.The . in the docker build command tells Docker to use the current folder to find a Dockerfile. Esse comando cria a imagem e cria um repositório local chamado Counter-Image que aponta para essa imagem.This command builds the image and creates a local repository named counter-image that points to that image. Após a conclusão desse comando, execute docker images para ver uma lista de imagens instaladas:After this command finishes, run docker images to see a list of images installed:

docker images
REPOSITORY                              TAG                 IMAGE ID            CREATED             SIZE
counter-image                           latest              e6780479db63        4 days ago          190MB
mcr.microsoft.com/dotnet/aspnet         3.1                 e6780479db63        4 days ago          190MB

Observe que as duas imagens compartilham o mesmo valor de ID DA IMAGEM.Notice that the two images share the same IMAGE ID value. O valor é o mesmo entre as duas imagens porque o único comando no Dockerfile era basear a nova imagem em uma imagem existente.The value is the same between both images because the only command in the Dockerfile was to base the new image on an existing image. Vamos adicionar três comandos ao Dockerfile.Let's add three commands to the Dockerfile. Cada comando cria uma nova camada de imagem com o comando final que representa os pontos de entrada do repositório de imagem de contador para.Each command creates a new image layer with the final command representing the counter-image repository entry points to.

COPY bin/Release/netcoreapp3.1/publish/ App/
WORKDIR /App
ENTRYPOINT ["dotnet", "NetCore.Docker.dll"]

O comando COPY informa ao Docker para copiar a pasta especificada em seu computador para uma pasta no contêiner.The COPY command tells Docker to copy the specified folder on your computer to a folder in the container. Neste exemplo, a pasta de publicação é copiada para uma pasta chamada aplicativo no contêiner.In this example, the publish folder is copied to a folder named App in the container.

O WORKDIR comando altera o diretório atual dentro do contêiner para o aplicativo.The WORKDIR command changes the current directory inside of the container to App.

O comando seguinte, ENTRYPOINT, informa ao Docker para configurar o contêiner para ser executado como um executável.The next command, ENTRYPOINT, tells Docker to configure the container to run as an executable. Quando o contêiner é iniciado, o comando ENTRYPOINT é executado.When the container starts, the ENTRYPOINT command runs. Quando esse comando terminar, o contêiner será interrompido automaticamente.When this command ends, the container will automatically stop.

No seu terminal, execute docker build -t counter-image -f Dockerfile . e, quando o comando terminar, execute docker images.From your terminal, run docker build -t counter-image -f Dockerfile . and when that command finishes, run docker images.

docker build -t counter-image -f Dockerfile .
Sending build context to Docker daemon  1.117MB
Step 1/4 : FROM mcr.microsoft.com/dotnet/aspnet:3.1
 ---> e6780479db63
Step 2/4 : COPY bin/Release/netcoreapp3.1/publish/ App/
 ---> d1732740eed2
Step 3/4 : WORKDIR /App
 ---> Running in b1701a42f3ff
Removing intermediate container b1701a42f3ff
 ---> 919aab5b95e3
Step 4/4 : ENTRYPOINT ["dotnet", "NetCore.Docker.dll"]
 ---> Running in c12aebd26ced
Removing intermediate container c12aebd26ced
 ---> cd11c3df9b19
Successfully built cd11c3df9b19
Successfully tagged counter-image:latest

docker images
REPOSITORY                              TAG                 IMAGE ID            CREATED             SIZE
counter-image                           latest              cd11c3df9b19        41 seconds ago      190MB
mcr.microsoft.com/dotnet/aspnet         3.1                 e6780479db63        4 days ago          190MB

Cada comando no Dockerfile gerou uma camada e criou uma ID DA IMAGEM.Each command in the Dockerfile generated a layer and created an IMAGE ID. A ID da imagem final (a sua será diferente) é cd11c3df9b19 e, em seguida, você criará um contêiner com base nessa imagem.The final IMAGE ID (yours will be different) is cd11c3df9b19 and next you'll create a container based on this image.

Criar um contêinerCreate a container

Agora que você tem uma imagem que contém o seu aplicativo, você pode criar um contêiner.Now that you have an image that contains your app, you can create a container. Você pode criar um contêiner de duas maneiras.You can create a container in two ways. Primeiro, criar um novo contêiner que foi interrompido.First, create a new container that is stopped.

docker create --name core-counter counter-image
0f281cb3af994fba5d962cc7d482828484ea14ead6bfe386a35e5088c0058851

O docker create comando acima criará um contêiner com base na imagem do contador-imagem .The docker create command from above will create a container based on the counter-image image. A saída desse comando mostra a ID DO CONTÊINER (a sua será diferente) do contêiner criado.The output of that command shows you the CONTAINER ID (yours will be different) of the created container. Para ver uma lista de todos os contêineres, use o comando docker ps -a:To see a list of all containers, use the docker ps -a command:

docker ps -a
CONTAINER ID    IMAGE            COMMAND                   CREATED           STATUS     PORTS    NAMES
0f281cb3af99    counter-image    "dotnet NetCore.Dock…"    40 seconds ago    Created             core-counter

Gerenciar o contêinerManage the container

O contêiner foi criado com um nome específico core-counter , esse nome é usado para gerenciar o contêiner.The container was created with a specific name core-counter, this name is used to manage the container. O exemplo a seguir usa o comando docker start para iniciar o contêiner e, em seguida, usa o comando docker ps para mostrar apenas os contêineres em execução:The following example uses the docker start command to start the container, and then uses the docker ps command to only show containers that are running:

docker start core-counter
core-counter

docker ps
CONTAINER ID    IMAGE            COMMAND                   CREATED          STATUS          PORTS    NAMES
2f6424a7ddce    counter-image    "dotnet NetCore.Dock…"    2 minutes ago    Up 11 seconds            core-counter

Da mesma forma, o comando docker stop interromperá o contêiner.Similarly, the docker stop command will stop the container. O exemplo a seguir usa o docker stop comando para parar o contêiner e, em seguida, usa o docker ps comando para mostrar que nenhum contêiner está em execução:The following example uses the docker stop command to stop the container, and then uses the docker ps command to show that no containers are running:

docker stop core-counter
core-counter

docker ps
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Conectar-se a um contêinerConnect to a container

Depois que um contêiner estiver em execução, você poderá se conectar a ele para ver a saída.After a container is running, you can connect to it to see the output. Use os comandos docker start e docker attach para iniciar o contêiner e inspecionar o fluxo de saída.Use the docker start and docker attach commands to start the container and peek at the output stream. Neste exemplo, a tecla Ctrl + C é usada para desanexar do contêiner em execução.In this example, the Ctrl+C keystroke is used to detach from the running container. Esse pressionamento de teclas encerrará o processo no contêiner, a menos que especificado de outra forma, o que interromperia o contêiner.This keystroke will end the process in the container unless otherwise specified, which would stop the container. O --sig-proxy=false parâmetro garante que Ctrl + C não pare o processo no contêiner.The --sig-proxy=false parameter ensures that Ctrl+C will not stop the process in the container.

Depois de desanexar do contêiner, reanexe para verificar se ele ainda está em execução e contando.After you detach from the container, reattach to verify that it's still running and counting.

docker start core-counter
core-counter

docker attach --sig-proxy=false core-counter
Counter: 7
Counter: 8
Counter: 9
^C

docker attach --sig-proxy=false core-counter
Counter: 17
Counter: 18
Counter: 19
^C

Excluir um contêinerDelete a container

Para os fins desse artigo, você não quer contêineres sem função alguma.For the purposes of this article you don't want containers just hanging around doing nothing. Exclua o contêiner que você criou anteriormente.Delete the container you previously created. Se o contêiner estiver em execução, interrompa-o.If the container is running, stop it.

docker stop core-counter

O exemplo a seguir lista todos os contêineres.The following example lists all containers. Em seguida, ele usa o comando docker rm para excluir o contêiner e, em seguida, verifica uma segunda vez para verificar qualquer contêiner em execução.It then uses the docker rm command to delete the container, and then checks a second time for any running containers.

docker ps -a
CONTAINER ID    IMAGE            COMMAND                   CREATED          STATUS                        PORTS    NAMES
2f6424a7ddce    counter-image    "dotnet NetCore.Dock…"    7 minutes ago    Exited (143) 20 seconds ago            core-counter

docker rm core-counter
core-counter

docker ps -a
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Execução únicaSingle run

O Docker fornece o comando docker run para criar e executar o contêiner como um único comando.Docker provides the docker run command to create and run the container as a single command. Este comando elimina a necessidade de executar docker create e, em seguida, docker start.This command eliminates the need to run docker create and then docker start. Você também pode definir esse comando para excluir automaticamente o contêiner quando o contêiner for interrompido.You can also set this command to automatically delete the container when the container stops. Por exemplo, use docker run -it --rm para fazer duas coisas: primeiro, use automaticamente o terminal atual para se conectar ao contêiner e, quando o contêiner terminar, remova-o:For example, use docker run -it --rm to do two things, first, automatically use the current terminal to connect to the container, and then when the container finishes, remove it:

docker run -it --rm counter-image
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
^C

O contêiner também passa parâmetros para a execução do aplicativo .NET Core.The container also passes parameters into the execution of the .NET Core app. Para instruir o aplicativo .NET Core a contar apenas a 3 passagens 3.To instruct the .NET Core app to count only to 3 pass in 3.

docker run -it --rm counter-image 3
Counter: 1
Counter: 2
Counter: 3

Com docker run -it o, o comando Ctrl + C interromperá o processo que está sendo executado no contêiner, o que, por sua vez, interromperá o contêiner.With docker run -it, the Ctrl+C command will stop process that is running in the container, which in turn, stops the container. Como o parâmetro --rm foi fornecido, o contêiner é automaticamente excluído quando o processo é interrompido.Since the --rm parameter was provided, the container is automatically deleted when the process is stopped. Verifique se ele não existe:Verify that it doesn't exist:

docker ps -a
CONTAINER ID    IMAGE    COMMAND    CREATED    STATUS    PORTS    NAMES

Alterar o ENTRYPOINTChange the ENTRYPOINT

O comando docker run também permite modificar o comando ENTRYPOINT do Dockerfile e executar outra coisa, mas apenas para esse contêiner.The docker run command also lets you modify the ENTRYPOINT command from the Dockerfile and run something else, but only for that container. Por exemplo, use o seguinte comando para executar bash ou cmd.exe.For example, use the following command to run bash or cmd.exe. Edite o comando conforme necessário.Edit the command as necessary.

Neste exemplo, ENTRYPOINT é alterado para cmd.exe.In this example, ENTRYPOINT is changed to cmd.exe. Ctrl + C é pressionado para encerrar o processo e parar o contêiner.Ctrl+C is pressed to end the process and stop the container.

docker run -it --rm --entrypoint "cmd.exe" counter-image

Microsoft Windows [Version 10.0.17763.379]
(c) 2018 Microsoft Corporation. All rights reserved.

C:\>dir
 Volume in drive C has no label.
 Volume Serial Number is 3005-1E84

 Directory of C:\

04/09/2019  08:46 AM    <DIR>          app
03/07/2019  10:25 AM             5,510 License.txt
04/02/2019  01:35 PM    <DIR>          Program Files
04/09/2019  01:06 PM    <DIR>          Users
04/02/2019  01:35 PM    <DIR>          Windows
               1 File(s)          5,510 bytes
               4 Dir(s)  21,246,517,248 bytes free

C:\>^C

Comandos essenciaisEssential commands

O Docker tem muitos comandos diferentes que criam, gerenciam e interagem com contêineres e imagens.Docker has many different commands that create, manage, and interact with containers and images. Esses comandos do Docker são essenciais para gerenciar seus contêineres:These Docker commands are essential to managing your containers:

Limpar recursosClean up resources

Durante este tutorial, você criou contêineres e imagens.During this tutorial, you created containers and images. Se quiser, exclua esses recursos.If you want, delete these resources. Use os seguintes comandos para:Use the following commands to

  1. Listar todos os contêineresList all containers

    docker ps -a
    
  2. Interrompa os contêineres que estão sendo executados por seu nome.Stop containers that are running by their name.

    docker stop counter-image
    
  3. Excluir o contêinerDelete the container

    docker rm counter-image
    

Em seguida, exclua todas as imagens que você não deseja mais em seu computador.Next, delete any images that you no longer want on your machine. Exclua a imagem criada pelo seu Dockerfile e exclua a imagem do .NET Core na qual o Dockerfile teve base.Delete the image created by your Dockerfile and then delete the .NET Core image the Dockerfile was based on. Você pode usar a ID DA IMAGEM ou a cadeia de caracteres formatada REPOSITÓRIO:TAG.You can use the IMAGE ID or the REPOSITORY:TAG formatted string.

docker rmi counter-image:latest
docker rmi mcr.microsoft.com/dotnet/aspnet:3.1

Use o comando docker images para ver uma lista de imagens instaladas.Use the docker images command to see a list of images installed.

Dica

Arquivos de imagem podem ser grandes.Image files can be large. Normalmente, você removeria contêineres temporários criados durante o teste e o desenvolvimento de seu aplicativo.Typically, you would remove temporary containers you created while testing and developing your app. Em geral, mantenha as imagens de base com o runtime instalado se você planeja construir outras imagens com base nesse runtime.You usually keep the base images with the runtime installed if you plan on building other images based on that runtime.

Próximas etapasNext steps