Neste laboratório, você aprenderá como gerenciar contêineres Docker usando o comando docker container kill. Começaremos criando e executando um contêiner simples. Em seguida, você explorará como parar um contêiner em execução usando o sinal padrão. Por fim, você aprenderá como matar um contêiner usando sinais personalizados, tanto por nome quanto por número, fornecendo habilidades essenciais para controlar o ciclo de vida de seus contêineres Docker.
Nesta etapa, aprenderemos como criar e executar um contêiner Docker simples. Um contêiner é uma unidade padrão de software que empacota o código e todas as suas dependências para que o aplicativo seja executado de forma rápida e confiável de um ambiente de computação para outro.
Primeiro, precisamos baixar a imagem Docker que usaremos. Usaremos a imagem ubuntu, que é um sistema operacional Ubuntu minimalista.
docker pull ubuntuEste comando baixa a imagem ubuntu do Docker Hub para sua máquina local. Você deve ver uma saída indicando o progresso do download.
Agora que temos a imagem, podemos executar um contêiner com base nela. Executaremos um comando simples dentro do contêiner.
docker run ubuntu echo "Hello from Docker!"Vamos detalhar este comando:
docker run: Este é o comando para executar um novo contêiner.ubuntu: Este é o nome da imagem que queremos usar.echo "Hello from Docker!": Este é o comando que será executado dentro do contêiner.Quando você executa este comando, o Docker criará um novo contêiner a partir da imagem ubuntu, executará o comando echo dentro dele e, em seguida, o contêiner será parado. Você deve ver a saída Hello from Docker! no seu terminal.
Para ver os contêineres que foram executados, incluindo aqueles que foram finalizados, você pode usar o comando docker ps -a.
docker ps -aEste comando lista todos os contêineres, tanto em execução quanto parados. Você deve ver uma entrada para o contêiner que acabou de executar, com o status "Exited" (Finalizado).
Na etapa anterior, executamos um contêiner que executou um comando e depois foi finalizado. Nesta etapa, executaremos um contêiner que permanece em execução e, em seguida, aprenderemos como pará-lo usando o sinal padrão.
Primeiro, vamos executar um contêiner que continuará em execução. Usaremos a imagem ubuntu novamente, mas desta vez executaremos um comando que aguarda indefinidamente.
docker run -d ubuntu sleep infinityVamos analisar o comando:
docker run: Comando para executar um novo contêiner.-d: Esta flag executa o contêiner em modo detached (desacoplado), o que significa que ele é executado em segundo plano e não bloqueia seu terminal.ubuntu: A imagem a ser usada.sleep infinity: O comando a ser executado dentro do contêiner. sleep infinity é um comando que fará com que o contêiner seja executado indefinidamente.Após executar este comando, o Docker imprimirá o ID do contêiner. Este contêiner agora está em execução em segundo plano.
Para ver os contêineres em execução, use o comando docker ps.
docker psVocê deve ver uma entrada para o contêiner que acabou de iniciar, com o status "Up" (Ativo) seguido pela duração em que ele está em execução. Anote o CONTAINER ID ou NAMES deste contêiner, pois precisaremos dele para parar o contêiner.
Agora, vamos parar o contêiner em execução usando o comando docker kill. Por padrão, docker kill envia o sinal SIGKILL para o processo principal do contêiner. SIGKILL é um sinal que encerra imediatamente um processo e não pode ser capturado ou ignorado.
Substitua <container_id_or_name> pelo ID ou nome real do seu contêiner em execução, obtido na saída de docker ps.
docker kill <container_id_or_name>Após executar este comando, o contêiner deve parar. Você pode verificar isso executando docker ps novamente. O contêiner não deve mais aparecer na lista de contêineres em execução.
Para ver o contêiner parado, você pode usar docker ps -a. Seu status agora deve ser "Exited" (Finalizado).
Na etapa anterior, matamos um contêiner em execução usando o sinal padrão. Nesta etapa, criaremos e executaremos outro contêiner que usaremos nas etapas seguintes para demonstrar como matar um contêiner com sinais personalizados.
Executaremos outro contêiner em modo detached (desacoplado) usando a imagem ubuntu e o comando sleep infinity, assim como antes.
docker run -d ubuntu sleep infinityEste comando iniciará um novo contêiner em segundo plano que será executado indefinidamente. O Docker imprimirá o novo ID do contêiner.
Para confirmar que o contêiner está em execução, use o comando docker ps.
docker psVocê deve ver o novo contêiner listado com o status "Up" (Ativo). Anote o CONTAINER ID ou NAMES deste contêiner. Usaremos este ID ou nome nas próximas etapas para matar o contêiner usando diferentes sinais.
Este contêiner agora está pronto para praticarmos o envio de diferentes sinais para ele.
Na etapa anterior, iniciamos um contêiner que está atualmente em execução. Nesta etapa, aprenderemos como matar este contêiner usando um sinal específico especificado por seu nome.
O comando docker kill permite que você envie um sinal específico para o processo principal dentro de um contêiner. Por padrão, ele envia SIGKILL, mas você pode especificar outros sinais. Um sinal comum usado para desligar aplicativos de forma graciosa é SIGTERM. SIGTERM é um sinal que solicita que um processo seja encerrado. Ao contrário de SIGKILL, os processos podem capturar SIGTERM e realizar operações de limpeza antes de sair.
Primeiro, identifique o ID ou nome do contêiner em execução da etapa anterior usando docker ps.
docker psAgora, use o comando docker kill com a flag -s para especificar o nome do sinal. Usaremos SIGTERM. Substitua <container_id_or_name> pelo ID ou nome real do seu contêiner em execução.
docker kill -s SIGTERM <container_id_or_name>Este comando envia o sinal SIGTERM para o processo principal do contêiner especificado. Se o aplicativo dentro do contêiner for projetado para lidar com SIGTERM, ele tentará desligar de forma graciosa. Se ele não lidar com SIGTERM ou não sair dentro de um determinado tempo limite, o Docker eventualmente enviará um SIGKILL para forçar a terminação.
Para verificar se o contêiner foi parado, execute docker ps novamente.
docker psO contêiner não deve mais ser listado como em execução. Você também pode usar docker ps -a para ver seu status, que deve ser "Exited" (Finalizado).
Na etapa anterior, matamos um contêiner usando um nome de sinal (SIGTERM). Nesta etapa, aprenderemos como matar um contêiner usando um sinal especificado por seu número.
Cada sinal tem um número correspondente. Por exemplo, SIGKILL é o sinal 9, e SIGTERM é o sinal 15. Você pode encontrar uma lista de sinais e seus números em um sistema Linux usando o comando kill -l.
kill -lEste comando exibirá uma lista de nomes de sinais e seus números correspondentes.
Agora, vamos executar outro contêiner que permanecerá em execução, semelhante às etapas anteriores.
docker run -d ubuntu sleep infinityObtenha o ID ou nome do contêiner em execução usando docker ps.
docker psAgora, usaremos o comando docker kill com a flag -s, mas desta vez forneceremos o número do sinal em vez do nome. Vamos usar o número do sinal 9, que corresponde a SIGKILL. Substitua <container_id_or_name> pelo ID ou nome real do seu contêiner em execução.
docker kill -s 9 <container_id_or_name>Este comando envia o sinal SIGKILL (número 9) para o processo principal do contêiner especificado. Como mencionado anteriormente, SIGKILL encerra imediatamente o processo.
Para verificar se o contêiner foi parado, execute docker ps novamente.
docker psO contêiner não deve mais ser listado como em execução. Você também pode usar docker ps -a para ver seu status, que deve ser "Exited" (Finalizado).
Usar números de sinal pode ser útil em scripts ou quando você precisa ser preciso sobre o sinal que está sendo enviado.
Neste laboratório, aprendemos os passos fundamentais para gerenciar contêineres Docker usando o comando docker container kill. Começamos criando e executando um contêiner simples baseado na imagem ubuntu, executando um comando básico e observando seu estado finalizado usando docker ps -a.
Posteriormente, exploramos como encerrar um contêiner em execução. Primeiro, demonstramos como matar um contêiner usando o sinal padrão e, em seguida, exploramos a flexibilidade do comando docker container kill terminando contêineres usando tanto nomes de sinais personalizados quanto seus valores numéricos correspondentes. Essa experiência prática forneceu conhecimento prático sobre como controlar o ciclo de vida dos contêineres Docker.
