Como construir uma imagem do docker usando um Dockerfile
- 3608
- 443
- Enrique Gutkowski PhD
As habilidades do Docker são altas de demanda principalmente porque, graças ao Docker Podemos automatizar a implantação de aplicativos dentro do chamado containers, criando ambientes personalizados que podem ser facilmente replicados em qualquer lugar do Docker A tecnologia é suportada. Neste tutorial, veremos como criar um Imagem do Docker do zero, usando um Dockerfile. Aprenderemos as instruções mais importantes que podemos usar para personalizar nossa imagem, como construir a imagem e como executar contêineres com base nela.
Neste tutorial, você aprenderá:
- Como criar uma imagem do Docker usando um Dockerfile
- Algumas das instruções do DockerFile mais usadas
- Como alcançar a persistência de dados em contêineres
Requisitos de software e convenções usadas
| Categoria | Requisitos, convenções ou versão de software usada |
|---|---|
| Sistema | Independente do OS |
| Programas | Docker |
| Outro |
|
| Convenções | # - requer que os comandos Linux sejam executados com privilégios root diretamente como usuário root ou por uso de sudo comando$ - Requer que os comandos do Linux sejam executados como um usuário não privilegiado regular |
Imagens e recipientes
Antes de começarmos, pode ser útil definir claramente o que queremos dizer quando falamos imagens e containers dentro do contexto de Docker. As imagens podem ser consideradas como blocos de construção do mundo do docker. Eles representam as “plantas” usadas para criar contêineres. De fato, quando um recipiente é criado, representa uma instância concreta das imagens em que é baseado.
Muitos contêineres podem ser criados a partir da mesma imagem. No restante deste artigo, aprenderemos a fornecer as instruções necessárias para criar uma imagem adaptada às nossas necessidades dentro de um Dockerfile, como realmente construir a imagem e como executar um contêiner com base nela.
Construa nossa própria imagem usando um Dockerfile
Para construir nossa própria imagem, usaremos um Dockerfile. Um DockerFile contém todas as instruções necessárias para criar e configurar uma imagem. Uma vez que nosso Dockerfile estivesse pronto, usaremos o Docker Build comando para realmente construir a imagem.
A primeira coisa que devemos fazer é criar um novo diretório para hospedar nosso projeto. Para o bem deste tutorial, construiremos uma imagem contendo o Apache servidor da web, por isso nomearemos o diretório raiz do projeto "Dockerized-Apache":
$ mkdir dockerized-apache
Este diretório é o que chamamos de construir contexto. Durante o processo de construção, todos os arquivos e diretórios contidos nele, incluindo o Dockerfile Criaremos, somos enviados para o daemon do Docker para que eles possam ser facilmente acessados, a menos que estejam listados no .Dockerignore arquivo.
Vamos criar nosso Dockerfile. O arquivo deve ser chamado Dockerfile e conterá, como dissemos acima, todas as instruções necessárias para criar uma imagem com os recursos desejados. Iniciamos nosso editor de texto favorito e começamos escrevendo as seguintes instruções:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] " A primeira instrução que devemos fornecer é DE: com ele, podemos especificar uma imagem existente que usaremos como base (isso é chamado de imagem base), para criar o nosso próprio. Nesse caso, nossa imagem base será Ubuntu. Além do nome da imagem, também usamos uma tag, a fim de especificar a versão da imagem que queremos usar, neste caso 18.10. Se nenhuma tag for especificada mais recente A tag é usada por padrão: isso fará com que a versão mais recente disponível da imagem base seja usada. Se a imagem ainda não estiver presente em nosso sistema, ela será baixada do DockerHub.
Depois de DE Instrução, usamos RÓTULO. Esta instrução é opcional, pode ser repetida várias vezes e é usada para adicionar metadados à nossa imagem. Nesse caso, o usamos para especificar o mantenedor de imagens.
A instrução de execução
Neste ponto, se corrermos Docker Build, Vamos apenas produzir uma imagem idêntica à base, exceto pelos metadados, adicionamos. Isso não seria útil para nós. Dissemos que queremos "dockerizar" o Apache servidor da web, então a próxima coisa a fazer em nosso Dockerfile, é fornecer uma instrução para instalar o servidor da web como parte da imagem. A instrução que vamos realizar esta tarefa é CORRER:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 O CORRER A instrução é usada para executar comandos em cima da imagem. Uma coisa muito importante a lembrar é que para cada CORRER Instrução que usamos, um nova camada é criado e adicionado à pilha. A esse respeito, o Docker é muito inteligente: as camadas já construídas serão "armazenadas em cache": isso significa que, se construirmos uma imagem com base em nosso Dockerfile, E então decidimos, por exemplo, adicionar outro CORRER Instrução (e, portanto, uma nova camada) no final, a construção não começará do zero, mas executará apenas as novas instruções.
Para que isso aconteça, é claro, as instruções já construídas no Dockerfile não deve ser modificado. É até possível para evitar esse comportamento completamente ao criar uma imagem, apenas usando o --Sem cache opção do Docker Build comando.
No nosso caso, usamos o CORRER instrução para executar o atualização apt-get && apt-get -y install apache2 comandos. Observe como passamos pelo -y opção para o instalação apt-get Comando: esta opção faz para que uma resposta afirmativa seja dada automaticamente a todas as confirmações exigidas pelo comando. Isso é necessário porque estamos instalando o pacote de forma não interativa.
Expondo a porta 80
Como sabemos, o servidor da Web Apache ouve Porta 80 Para conexões padrão. Devemos instruir o Docker a tornar essa porta acessível no contêiner. Para realizar a tarefa, usamos o EXPOR função e forneça o número da porta. Por razões de segurança, a porta especificada é aberta apenas quando o contêiner é lançado. Vamos adicionar esta instrução ao nosso Dockerfile:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 Construindo a imagem
Neste ponto, já podemos tentar construir nossa imagem. De dentro do diretório raiz do nosso projeto, "Dockerized-apache", executamos o seguinte comando:
$ sudo docker build -t linuxconfig/dockerized -apache .
Vamos examinar o comando. Primeiro de tudo, prefixamos o comando com sudo, a fim de executá -lo com privilégios administrativos. É possível evitar isso, adicionando um usuário ao Docker grupo, mas isso representa um risco de segurança. O -t opção que fornecemos, abreviação de --marcação, Vamos aplicar um nome de repositório e opcionalmente uma tag à nossa imagem se a construção for bem -sucedida.
finalmente, o . instrui o docker a procurar o Dockerfile no diretório atual. Assim que lançarmos o comando, o processo de construção começará. As mensagens de progresso e construção serão exibidas na tela:
Enviando contexto de construção para Docker Daemon 2.048 KB Etapa 1/4: De Ubuntu: 18.10 tentando puxar o Docker do Repositório.io/biblioteca/ubuntu… . [… .] Em alguns minutos nossa imagem deve ser criada com sucesso. Para verificar, podemos executar o Imagens do Docker Comando, que retorna uma lista de todas as imagens existentes em nosso repositório local do Docker:
$ sudo docker imagens repositório tag Id criado tamanho linuxconfig/dockerized-apache mais recente 7ab7b6873614 2 minutos atrás 191 mb Como esperado, a imagem aparece na lista. Como podemos notar, já que não fornecemos uma tag (apenas um nome de repositório, LinuxConfig/Dockerized-Apache) o mais recente A tag foi aplicada automaticamente à nossa imagem. Um EU IA também foi atribuído ao TI, 7AB7B6873614: Podemos usá -lo para fazer referência à imagem em comandos futuros.
Lançando um recipiente baseado na imagem
Agora que nossa imagem está pronta, podemos criar e lançar um recipiente com base nisso. Para realizar a tarefa, usamos o Docker Run comando:
$ sudo docker run -name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache apachectl -d em primeiro plano
Vamos examinar o comando acima. A primeira opção que fornecemos foi --nome: Com ele, especificamos um nome para o contêiner, neste caso "LinuxConfig-apache". Se omitissemos esta opção, um nome gerado aleatório seria atribuído ao nosso contêiner.
O -d opção (abreviação de --Desapear) faz com que o contêiner seja executado em segundo plano.
O -p opção, abreviação de --publicar, é necessário para publicar uma porta de contêiner (ou uma variedade de portas) ao sistema host. A sintaxe da opção é a seguinte:
-p localhost_port: contêiner_port
Neste caso, publicamos o Porta 80 anteriormente expostos no contêiner, ao host Porta 8080. Por uma questão de completude, devemos dizer que também é possível usar o -P opção (abreviação de --Publish-All) em vez disso, fazendo com que todas as portas expostas no recipiente sejam mapeadas para aleatório portas no host.
As duas últimas coisas que especificamos no comando acima são: o imagem o contêiner deve se basear e o comando Para funcionar quando o contêiner é iniciado, o que é opcional. A imagem é claro LinuxConfig/Dockerized-Apache, aquele que construímos antes.
O comando que especificamos é Apachectl -d em primeiro plano. Com este comando o Apache O servidor da web é lançado em primeiro plano Modo: isso é obrigatório para funcionar no contêiner. O Docker Run O comando executa o comando especificado em um novo recipiente:
$ sudo docker run --name=linuxconfig-apache -d -p 8080:80 linuxconfig/dockerized-apache apachectl -D FOREGROUND a51fc9a6dd66b02117f00235a341003a9bf0ffd53f90a040bc1122cbbc453423 Qual é o número impresso na tela? É o EU IA do recipiente! Depois de termos o contêiner em funcionamento, devemos acessar a página servida pelo padrão Apache VirtualHost no LocalHost: 8080 endereço (porta 8080 No host é mapeado na porta 80 no contêiner):
Índice Apache padrão.Página HTML
Nossa configuração está funcionando corretamente. Se executarmos o Docker PS Comando, que lista todos os contêineres ativos do sistema, podemos recuperar informações sobre nosso contêiner: id (versão curta, mais fácil de referir a linha de comando para um humano), a imagem de que foi executada, o comando usado, sua criação tempo e status atual, mapeamento de portas e nome.
$ sudo docker ps contêiner com comando de imagem criada portas de status nomes nomes a51fc9a6dd66 linuxconfig/dockerized -apache "apachectl -d diante ..." 28 segundos atrás de 28 segundos 0.0.0.0: 8080-> 80/tcp linuxconfig-apache Para impedi -lo, o contêiner tudo o que precisamos fazer é referenciá -lo por seu id ou nome e executar Docker Stop comando. Por exemplo:
$ sudo docker pare linuxconfig-apache
Para começar de novo:
$ sudo docker start linuxconfig-apache
Execute o comando diretamente através do Dockerfile
Desde aqui, construímos uma imagem básica e em tempo de execução, usando o Docker Run Comando, especificamos o comando a ser lançado quando o contêiner é iniciado. Às vezes queremos especificar o último diretamente dentro do Dockerfile. Podemos fazer isso de duas maneiras: usando Cmd ou PONTO DE ENTRADA.
Ambas as instruções podem ser usadas para o mesmo objetivo, mas se comportam de maneira diferente quando um comando também é especificado na linha de comando. Vamos ver como.
A instrução CMD
O Cmd As instruções podem basicamente ser usadas em duas formas. O primeiro é o exec forma:
Cmd ["/usr/sbin/apachectl", "-d", "em primeiro plano"]
O outro é o concha forma:
CMD/usr/sbin/apachectl -d em primeiro plano
O exec de geralmente é preferido. Vale a pena notar que, ao usar o formulário Exec, um shell não é invocado, portanto, as expansões variáveis não acontecerão. Se for necessária uma expansão variável, podemos usar o concha forma ou podemos invocar uma concha diretamente no exec modo, como:
Cmd ["sh", "-c", "echo", "$ home"]
O Cmd a instrução pode ser especificada apenas uma vez no Dockerfile. Se múltiplo Cmd As opções são fornecidas, apenas a última terá efeito. O objetivo da instrução é fornecer um padrão comando a ser lançado quando o contêiner iniciar:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 cmd ["/usr/sbin/apachectl "," -d "," em primeiro plano "] O comando especificado com Cmd dentro de Dockerfile, funciona como padrão e será substituído se outro comando for especificado na linha de comando ao executar Docker Run.
A instrução de ponto de entrada
O PONTO DE ENTRADA A instrução também pode ser usada para configurar um comando a ser usado quando o contêiner é iniciado e gostar Cmd, ambos exec e concha o formulário pode ser usado com ele. A grande diferença entre os dois é que um comando passado da linha de comando não substituirá o especificado com PONTO DE ENTRADA: Em vez disso, será anexado para isso.
Ao usar esta instrução, podemos especificar um comando básico e modificá -lo com as opções que fornecemos ao executar o Docker-Run comando, fazendo nosso contêiner se comportar como um executável. Vamos ver um exemplo com nosso Dockerfile:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 entrada ["/usr/sbin/apachectl "] Neste caso, substituímos o Cmd instrução com PONTO DE ENTRADA e também removeu o -D em primeiro plano opção do formato EXEC. Suponha que agora reconstruímos a imagem e recrie o contêiner usando o seguinte comando:
$ sudo docker run -name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache -d em primeiro plano
Quando o recipiente começa, o -D em primeiro plano Argumentos são anexados ao comando fornecido no Dockerfile com o PONTO DE ENTRADA instrução, mas somente se estiver usando o exec forma. Isso pode ser verificado executando o Docker PS Comando (aqui adicionamos algumas opções ao comando, para melhor exibir e formatar sua saída, selecionando apenas as informações de que precisamos):
$ sudo docker ps-não trunc--format ".Nomes \ t .Command "LinuxConfig -apache"/usr/sbin/apachectl -d em primeiro plano " Assim como Cmd, o PONTO DE ENTRADA As instruções podem ser fornecidas apenas uma vez. Se aparecer várias vezes no Dockerfile, apenas a última ocorrência será considerada. É possível substituir o padrão PONTO DE ENTRADA da imagem da linha de comando, usando o --ponto de entrada opção do Docker Run comando.
Combinando CMD e ponto de entrada
Agora que conhecemos a peculiaridade do Cmd e PONTO DE ENTRADA Instruções, também podemos combiná -los. O que podemos obter fazendo isso? Podemos usar PONTO DE ENTRADA para especificar um comando de base válido e o Cmd instrução para especificar parâmetros padrão para isso.
O comando será executado com esses parâmetros padrão por padrão, a menos que os substituímos da linha de comando ao executar Docker Run. Aderindo ao nosso Dockerfile, Poderíamos escrever:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 entrada ["/usr/sbin/apachectl "] cmd [" -d "," em primeiro plano "] Se reconstruímos a imagem deste Dockerfile, Remova o recipiente anterior que criamos e relançar o Docker Run comando sem especificar nenhum argumento adicional, o /usr/bin/apachectl -d em primeiro plano O comando será executado. Se fornecermos alguns argumentos, eles substituirão os especificados no Dockerfile com o Cmd instrução. Por exemplo, se executarmos:
$ sudo docker run -name = linuxconfig -apache -d -p 8080: 80 linuxconfig/dockerized -apache -x
O comando que será executado ao iniciar o contêiner será /usr/bin/apachectl -x. Vamos verificar:
$ sudo docker ps-não trunc--format ".Nomes \ t .Comando "LinuxConfig -apache"/usr/sbin/apachectl -x " O comando lançado foi o esperado: o -X a opção, a propósito, faz com que o daemon httpd seja lançado em modo de depuração.
Copiando arquivos no contêiner
Nosso servidor Apache "Dockerized" funciona. Como vimos, se navegarmos para LocalHost: 8080, Visualizamos a página de boas -vindas do Apache padrão. Agora, digamos que temos um site pronto para ser enviado com o contêiner, como podemos "carregá -lo" para que o Apache o sirva em vez disso?
Bem, para o bem deste tutorial, apenas substituiremos o índice padrão.arquivo html. Para realizar a tarefa, podemos usar o CÓPIA DE instrução. Suponha que tenhamos um índice alternativo.Arquivo HTML dentro da raiz do nosso projeto (nosso contexto de construção) com este conteúdo:
Olá!
Este arquivo foi copiado no contêiner com a instrução de cópia!
Queremos carregá -lo e copiá -lo para o /var/www/html diretório dentro do recipiente, portanto dentro de nosso Dockerfile Nós adicionamos o CÓPIA DE instrução:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 entrada ["/usr/sbin/apachectl "] cmd [" -d "," em primeiro plano "] Índice de cópia.html/var/www/html/index.html Nós reconstruímos a imagem e o contêiner. Se agora navegue para LocalHost: 8080, Veremos a nova mensagem:
# nova mensagem
O CÓPIA DE As instruções podem ser usadas para copiar arquivos e diretórios. Quando o caminho de destino não existe, ele é criado dentro do recipiente. Todos os novos arquivos e diretórios são criados com um Uid e Gid de 0.
Outra solução de possibilidade de copiar arquivos dentro do contêiner é usar o ADICIONAR instrução, que é mais poderosa do que CÓPIA DE. Com esta instrução, podemos copiar arquivos, diretórios, mas também URLs. Além disso, se copiarmos um local Arquivo TAR Com um formato compactado reconhecido, ele será automaticamente compactado e copiado como um diretório dentro do contêiner.
A estratégia ideal seria usar CÓPIA DE a menos que os recursos adicionais fornecidos por ADICIONAR são realmente necessários.
Criando um volume
No exemplo anterior, para demonstrar como o CÓPIA DE Funcionamentos de instrução, substituímos o índice padrão.Arquivo HTML do Apache VirtualHost padrão dentro do contêiner.
Se pararmos e iniciarmos o contêiner, ainda encontraremos a modificação que fizemos, mas se o contêiner por algum motivo for removido, todos os dados contidos em sua camada gravável serão perdidos com ele. Como resolver este problema? Uma abordagem é usar o VOLUME instrução:
De Ubuntu: 18.10 Rótulo para manter = "[email protected] "Run Apt-Get Update && apt-get -y install Apache2 Exponha 80 entrada ["/usr/sbin/apachectl "] cmd [" -d "," em primeiro plano "] Índice de cópia.html/var/www/html/index.volume html/var/www/html O VOLUME a instrução leva um ou mais diretórios (neste caso /var/www/html) e faz com que eles sejam usados como MountPoints para volumes externos e com nome aleatório gerados quando o contêiner é criado.
Dessa forma, os dados que colocamos nos diretórios usados como MountPoints serão persistidos dentro dos volumes montados e ainda existirão mesmo se o contêiner for destruído. Se um diretório definido para ser usado como um MountPoint já contiver dados no momento da inicialização, esses dados são copiados dentro do volume que é montado nele.
Vamos reconstruir a imagem e o contêiner. Agora podemos verificar se o volume foi criado e seu uso inspecionando o contêiner:
$ sudo docker inspecionar linuxconfig-apache [… .] "Mounts": [ "Type": "volume", "Name": "8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61", "Source": "/var/lib/docker/volumes/8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61/_data", "Destination": "/var/ www/html "," driver ":" local "," mode ":" "," rw ": verdadeiro," propagação ":" "], [.. .] Como já foi dito, o volume sobreviverá mesmo depois que o contêiner for destruído para que nossos dados não sejam perdidos.
O VOLUME instrução dentro do Dockefile, Como podemos ver na saída do comando Docker Inspect acima, faz com que um volume de nome aleatoriamente seja criado. Para definir um Volume nomeado, ou para montar um volume já existente dentro de um recipiente, devemos especificá -lo em tempo de execução, ao executar o Docker Run comando, usando o -v opção (abreviação de --volume). Vamos ver um exemplo:
$ sudo docker run - -name = linuxconfig -apache -d -p 8080: 80 -v myvolume:/var/www/html linuxconfig/Dockerizado -apache
No comando acima, usamos o -v opção especificando o Nome do volume (muito importante: observe que não é um caminho, mas um nome simples) e o ponto de montagem Dentro do recipiente usando a seguinte sintaxe:
:
Quando executarmos esse comando, o volume chamado "MyVolume" será montado no caminho específico dentro do contêiner (o volume será criado se ainda não existir). Como dissemos antes, se o volume estiver vazio, os dados já existentes no MountPoint dentro do recipiente serão copiados dentro dele. Usando o Docker Volume LS Comando, podemos confirmar um volume com o nome que especificamos foi criado:
$ sudo docker volume ls driver volume nome myvolume local Para remover um volume, usamos o Docker Volume RM comando e forneça o nome do volume para remover. Docker, no entanto, não nos permitirá remover um volume usado por um contêiner ativo:
$ sudo docker volume RM Resposta de erro do myvolume do Daemon: Não é possível remover o volume, volume ainda em uso: Remover MyVolume: o volume está em uso - [95381B7B6003F6165DFE2E1912D2F82711AC26E222CF26BC1BC1F8227167E Outra abordagem para a persistência dos dados, especialmente útil durante o desenvolvimento, é montagem de ligação um diretório host dentro do contêiner. Essa abordagem tem a vantagem de nos deixar trabalhar em nosso código localmente com nossas ferramentas favoritas e ver o efeito das mudanças imediatamente refletidas dentro do contêiner, mas tem uma grande desvantagem: o contêiner se torna dependente da estrutura do diretório host.
Por esse motivo, como a portabilidade é um dos principais alvos do Docker, não é possível definir um montagem de ligação Dentro de um Dockerfile, mas apenas em tempo de execução. Para realizar esta tarefa, usamos o -v opção de Docker Run comando novamente, mas desta vez fornecemos o caminho de um diretório dentro do sistema de arquivos host em vez de um nome de volume:
$ sudo docker run - -name = linuxconfig -apache -d -p 8080: 80 -v/path/on/host:/var/www/html linuxconfig/Dockerized -apache
Ao iniciar o comando acima, o diretório host/caminho/host será montado em/var/www/html dentro do contêiner. Se o diretório no host não existir, ele é criado automaticamente. Nesse caso, os dados no diretório MountPoint dentro do contêiner (/var/www/html em nosso exemplo) são não copiado para o diretório host que é montado nele, pois acontece para os volumes.
Conclusão
Neste tutorial, aprendemos os conceitos básicos necessários para criar e construir uma imagem do docker usando um Dockerfile e como executar um contêiner com base nele. Construímos uma imagem muito simples que vamos executar uma versão "Dockerized" do servidor da Web Apache. No processo, vimos como usar o DE Instrução, que é obrigatória para especificar uma imagem base para trabalhar, o RÓTULO instrução para adicionar metadados à nossa imagem, o EXPOR instrução para declarar as portas a serem expostas no recipiente. Também aprendemos a mapear os referidos portos para o (s) porta (s) do sistema host.
Aprendemos a usar oCORRER Instrução para executar comandos na imagem e aprendemos a especificar um comando a ser executado quando o contêiner é iniciado a partir da linha de comando e dentro do Dockerfile. Vimos como fazer isso usando o Cmd e PONTO DE ENTRADA instruções e quais são as diferenças entre os dois. Finalmente, vimos como CÓPIA DE dados dentro do contêiner e como obter persistência de dados usando volumes. Em nossos exemplos, discutimos apenas um pequeno subconjunto das instruções que podem ser usadas em um Dockerfile.
Para uma lista completa e detalhada, consulte a documentação oficial do Docker. Enquanto isso, se você quiser saber como construir um inteiro LÂMPADA Empilhe usando o Docker e a ferramenta Docker-Compompose, você pode dar uma olhada em nosso artigo sobre como criar uma pilha de lâmpadas baseada em docker usando o Docker-Compose no Ubuntu 18.04 Bionic Beaver Linux.
Tutoriais do Linux relacionados:
- Uma introdução à automação, ferramentas e técnicas do Linux
- Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
- Coisas para instalar no Ubuntu 20.04
- Como montar a imagem ISO no Linux
- Como criar backups incrementais do sistema com o tempo de tempo…
- Kubernetes vs Docker, qual é a diferença?
- Como redimensionar uma imagem de disco QCOW2 no Linux
- Como criar uma pilha de lâmpadas à base de docker usando o docker em…
- Mastering Bash Script Loops
- Coisas para fazer depois de instalar o Ubuntu 22.04 Jellyfish…
- « Introdução ao Grep e expressões regulares
- Como recuperar arquivos excluídos com o principal em Linux »