Introdução
Neste laboratório, exploraremos como usar o comando docker context inspect para visualizar informações detalhadas sobre os contextos do Docker. Os contextos do Docker são essenciais para gerenciar conexões a diferentes daemons do Docker. Começaremos inspecionando o contexto Docker padrão, que se conecta ao daemon local.
Em seguida, criaremos um novo contexto para fins de demonstração e, em seguida, usaremos docker context inspect para examinar seus detalhes por nome. Finalmente, aprenderemos como formatar a saída do comando inspect de diferentes maneiras, especificamente como JSON e usando um template Go, para extrair informações específicas sobre um contexto.
Inspecionar o contexto Docker padrão
Nesta etapa, exploraremos o contexto Docker padrão. Um contexto Docker é uma maneira de gerenciar conexões a diferentes daemons do Docker. Por padrão, o Docker usa um contexto chamado default, que se conecta ao daemon Docker local.
Para inspecionar o contexto Docker padrão, usamos o comando docker context inspect seguido pelo nome do contexto.
docker context inspect default
Este comando exibirá informações detalhadas sobre o contexto default, incluindo seu endpoint, tipo e outros detalhes de configuração. A saída estará em formato JSON.
[
{
"Name": "default",
"Current": true,
"Endpoint": {
"Docker": {
"Host": "unix:///var/run/docker.sock"
}
},
"Metadata": {},
"Storage": "meta/contexts/default"
}
]
A saída mostra que o contexto default é o contexto atual ("Current": true) e seu endpoint está definido como unix:///var/run/docker.sock, que é o socket Unix padrão para o daemon Docker em sistemas Linux.
Criar um novo contexto para demonstração
Nesta etapa, criaremos um novo contexto Docker. Criar um novo contexto permite que você defina uma conexão a um daemon Docker diferente, que pode estar em uma máquina remota ou em uma configuração diferente na mesma máquina. Para esta demonstração, criaremos um contexto que ainda aponta para o daemon Docker local, mas terá um nome diferente.
Para criar um novo contexto, usamos o comando docker context create seguido pelo nome do novo contexto e as informações do endpoint. Como estamos nos conectando ao daemon local, o endpoint será o mesmo do contexto padrão: unix:///var/run/docker.sock.
Vamos criar um novo contexto chamado my-context.
docker context create my-context --docker "host=unix:///var/run/docker.sock"
Após executar este comando, você deverá ver uma saída indicando que o contexto foi criado.
my-context
Isso confirma que um novo contexto chamado my-context foi criado com sucesso, apontando para o daemon Docker local.
Inspecionar o contexto recém-criado por nome
Na etapa anterior, criamos um novo contexto Docker chamado my-context. Agora, vamos inspecionar este contexto recém-criado para ver seus detalhes. Semelhante à inspeção do contexto padrão, usamos o comando docker context inspect, mas desta vez especificamos o nome do nosso novo contexto.
docker context inspect my-context
Este comando exibirá os detalhes de configuração para o my-context que acabamos de criar. A saída será novamente em formato JSON.
[
{
"Name": "my-context",
"Current": false,
"Endpoint": {
"Docker": {
"Host": "unix:///var/run/docker.sock"
}
},
"Metadata": {},
"Storage": "meta/contexts/my-context"
}
]
Observe que a saída para my-context é semelhante ao contexto default, pois ambos apontam para o daemon Docker local. No entanto, o campo "Current" é false para my-context, indicando que ele não é o contexto atualmente ativo. O contexto default ainda é o ativo.
Inspecionar o contexto e formatar a saída como JSON
Nesta etapa, solicitaremos explicitamente que a saída do comando docker context inspect seja no formato JSON. Embora a saída padrão já seja JSON, usar a flag --format json é uma boa prática quando você precisa especificamente da saída JSON, por exemplo, ao canalizar a saída para outras ferramentas para processamento.
Inspecionaremos o my-context que criamos na etapa anterior e formataremos a saída como JSON.
docker context inspect my-context --format json
Este comando produzirá a mesma saída JSON que na etapa anterior, mas demonstra explicitamente como usar a flag --format para especificar o formato de saída.
[
{
"Name": "my-context",
"Current": false,
"Endpoint": {
"Docker": {
"Host": "unix:///var/run/docker.sock"
}
},
"Metadata": {},
"Storage": "meta/contexts/my-context"
}
]
Usar a flag --format json é particularmente útil quando você deseja analisar programaticamente a saída dos comandos Docker.
Inspecionar o contexto e formatar a saída usando um template Go
Nesta etapa final, exploraremos como formatar a saída de docker context inspect usando um template Go. Este é um recurso poderoso que permite extrair informações específicas da saída JSON e exibi-las em um formato personalizado.
Inspecionaremos o my-context e usaremos um template Go para exibir apenas o nome do contexto e o endpoint do host Docker. A sintaxe do template usa chaves duplas {{ }} para envolver expressões. Podemos acessar campos dentro da saída JSON usando a notação de ponto, por exemplo, .Name para o nome do contexto e .Endpoint.Docker.Host para o endpoint do host Docker.
docker context inspect my-context --format '{{.Name}}: {{.Endpoint.Docker.Host}}'
Este comando usará o template Go fornecido para formatar a saída. Você deve ver o nome do contexto seguido pelo seu endpoint do host Docker.
my-context: unix:///var/run/docker.sock
Isso demonstra como os templates Go podem ser usados para personalizar a saída dos comandos Docker, facilitando a extração e o processamento de dados específicos.
Resumo
Neste laboratório, aprendemos como usar o comando docker context inspect para visualizar detalhes sobre os contextos do Docker. Começamos inspecionando o contexto padrão, que se conecta ao daemon Docker local. Em seguida, criamos um novo contexto chamado my-context para fins de demonstração, também apontando para o daemon local.
Exploramos ainda mais o comando docker context inspect inspecionando o contexto recém-criado por nome. Finalmente, demonstramos como formatar a saída do comando inspect de diferentes maneiras, especificamente como JSON e usando um template Go, para extrair e exibir informações específicas sobre um contexto.
