One place for hosting & domains

      Remotos

      Como usar o nsh para executar comandos remotos seguros no Ubuntu 18.04


      Introdução

      Muitas vezes é difícil gerenciar várias máquinas em um banco de dados diariamente. Ainda que o Secure Shell (SSH) seja uma boa escolha para o acesso remoto, o protocolo em si possui alguns inconvenientes tanto em conveniência como em segurança.

      Por exemplo, máquinas remotas precisam ter um endereço IP público e uma porta redirecionada para acessá-los, o que os expõe à Internet, ou pelo menos a uma rede maior. Isso é especialmente preocupante caso use uma senha para autenticação em vez de um par de chaves público e privado. Além disso, caso não conheça a chave pública da máquina remota antecipadamente, você fica vulnerável a um ataque “man-in-the-middle”. E muitas máquinas remotas que você vai querer acessar não têm endereço IP público ou têm um endereço IP dinâmico que você não sabe.

      Além disso, o SSH exige uma conexão por sessão remota. Se um usuário precisa executar um único comando em centenas ou mesmo milhares de máquinas, é preciso primeiro estabelecer uma conexão com cada máquina com um handshake TCP, que é menos eficiente.

      O NKN Shell, ou nsh, é uma alternativa ao SSH que fornece uma maneira conveniente e segura de executar comandos remotos. O nsh aproveita a rede pública global do NKN, que fornece transmissão de dados segura e descentralizada. A arquitetura usa endereços únicos que contêm uma chave pública usada tanto para o roteamento quanto para a criptografia end-to-end sem nenhuma infraestrutura de chave pública (PKI). A rede também não exige que o servidor remoto tenha um endereço IP público. O servidor remoto precisa ter acesso à Internet e ser capaz de estabelecer conexões HTTP de saída e de websocket. Como resultado, suas máquinas remotas não são expostas à Internet aberta.

      Neste tutorial, você usará o daemon do NKN shell e o aplicativo Xterm do cliente NKN Shell para executar comandos em uma máquina remota. Para fazer isso, você instalará e configurará o daemon do NKN Shell em uma máquina remota com acesso à internet, gerará um par de chaves e fará sua conexão de um cliente.

      Pré-requisitos

      Para seguir este tutorial, você precisará do seguinte:

      Passo 1 — Instalando o NKN Shell em um servidor remoto

      Primeiro, instale o daemon do NKN shell (nsd) no seu servidor. Esse aplicativo invoca o nkn-multiclient, que se conectará à rede pública do NKN e receberá um endereço para o roteamento. Então, o daemon escutará comandos shell de entrada de clientes autenticados e listados, executará esses comandos e, em seguida, enviará os resultados de volta.

      Comece baixando os binários nshd pré-compilados do GitHub mais recentes:

      • wget https://github.com/nknorg/nkn-shell-daemon/releases/latest/download/linux-amd64.tar.gz

      Descompacte o arquivo:

      • tar -zxvf linux-amd64.tar.gz

      Então, mova os arquivos para o diretório /usr/local/bin, para que eles estejam disponíveis em todo o sistema:

      • sudo mv ./linux-amd64/* /usr/local/bin/

      Em seguida, você configurará isso para ser executado como um processo daemon usando o Systemd, para que ele seja reiniciado caso o servidor seja redefinido.

      Crie um arquivo chamado nshd.service em /etc/systemd/system:

      • sudo nano /etc/systemd/system/nshd.service

      Adicione a seguinte definição de serviço ao arquivo para configurar o serviço:

      /etc/systemd/system/nshd.service

      [Unit]
      Description=NKN Shell Daemon
      After=network.target
      
      [Service]
      Type=simple
      User=root
      Group=root
      Restart=always
      ExecStart=/usr/local/bin/nshd
      
      [Install]
      WantedBy=multi-user.target
      

      Saiba mais sobre arquivos de unidade do Systemd em Entendendo unidades do Systemd e arquivos de unidade.

      Salve o arquivo e saia do editor. Então, habilite e inicie o serviço nshd com os seguintes comandos:

      • sudo systemctl enable nshd.service
      • sudo systemctl start nshd.service

      Execute o seguinte comando para garantir que o serviço esteja ativo e iniciado:

      • sudo systemctl status nshd.service

      Você verá que o status está ativo:

      Output

      ● nshd.service - NKN Shell Daemon Loaded: loaded (/etc/systemd/system/nshd.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2020-02-19 19:16:02 UTC; 7s ago Main PID: 3457 (nshd) Tasks: 10 (limit: 1152) CGroup: /system.slice/nshd.service └─3457 /usr/local/bin/nshd Feb 19 19:16:02 your_hostname systemd[1]: Started NKN Shell Daemon. Feb 19 19:16:03 your_hostname nshd[3457]: Create directory /etc/nshd/ Feb 19 19:16:03 your_hostname nshd[3457]: Create password and save to file /etc/nshd/wallet.pswd Feb 19 19:16:03 your_hostname nshd[3457]: Create wallet and save to file /etc/nshd/wallet.json Feb 19 19:16:03 your_hostname nshd[3457]: Create authorized pubkeys file /etc/nshd/authorized_pubkeys Feb 19 19:16:03 your_hostname nshd[3457]: Listening at d46567b883a3070ee3fe879d9fa2d5dc55a95f79ff2797c42df36c6979e5c4Aba

      Para se conectar ao seu servidor, você precisará obter seu endereço NKN, que pode ser encontrado no resultado do comando anterior. Também é possível executar o seguinte comando para obter o endereço:

      Você verá seu endereço aparecer:

      Output

      e70ca28ede84fc0659f2869255e8a393aef35b4fa5a7e036f29127c7dba75383

      Anote este endereço, uma vez que precisará dele para se conectar ao seu servidor.

      Agora que o daemon está em execução e escutando, é possível configurar o cliente baseado na Web para falar com o servidor.

      Passo 2 — Configurando as permissões para o cliente NKN Shell

      Você precisará de um cliente compatível que possa se conectar à máquina remota. Neste tutorial, você usará o cliente Xterm do NKN Shell, um cliente NKN shell baseado na Web. Há várias maneiras diferentes de executá-lo:

      Neste tutorial, você usará a versão hospedada. Na sua máquina local, abra o navegador Web e navegue até https://nsh.nkn.org. Você verá uma tela de boas vindas:

      O cliente do Shell

      Clique em Generate New Key Pair (Gerar novo par de chaves). Suas chaves serão geradas e exibidas como mostrado na imagem seguinte:

      O par de chaves gerado

      Nota: quando gerar um novo par de chaves, você verá um seed secreto. Mantenha esse seed secreto seguro, assim como você faria com sua chave privada SSH. Qualquer um que tenha esse seed secreto pode usá-lo para regenerar sua chave pública e, em seguida, executar comandos em suas máquinas remotas. Seu navegador se lembrará desse seed, mas você deve copiá-lo em um lugar seguro para que possa usá-lo novamente em uma nova máquina.

      Salve o seed secreto em um lugar seguro. É possível usá-lo mais tarde para regenerar sua chave pública para que você possa se conectar a partir de uma máquina de cliente diferente.

      Como trata-se de um novo par de chaves, é preciso adicionar a chave pública ao arquivo /etc/nshd/authorized_pubkeys no seu servidor.

      O /etc/nshd/authorized_pubkeys tem um papel semelhante ao arquivo ~/authorized_keys, que controla quais chaves públicas SSH podem fazer login. O arquivo authorized_pubkeys especifica qual usuário está associado a uma chave. Para fins de segurança, faça login usando um usuário não raiz neste tutorial, de modo que a chave pública gerada seja associada com seu usuário sammy criado no tutorial pré-requisito deste artigo, Configuração inicial de servidor.

      Para associar um usuário à chave pública, será necessário obter o ID de usuário (UID) e o ID de grupo (GID) deste usuário. Execute o seguinte comando no seu servidor, enquanto logado como o usuário sammy:

      Você verá o UID e o GID do usuário:

      Output

      uid=1000(sammy) gid=1000(sammy) groups=1000(sammy),27(sudo)

      Agora, abra o arquivo authorized_pubkeys no seu editor:

      • sudo nano /etc/nshd/authorized_pubkeys

      Adicione uma linha única que contenha a chave pública, UID e GID, separados por espaços:

      authorized_pubkeys

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000
      

      Salve o arquivo.

      Verifique se o arquivo contém o conteúdo correto:

      • cat /etc/nshd/authorized_pubkeys

      Você verá sua chave impressa na tela:

      Output

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000

      Então, reinicie o daemon nshd para aplicar as alterações:

      • sudo systemctl restart nshd.service

      Agora, vamos testá-lo. Para isso, conecte-se ao servidor e execute um comando.

      Passo 3 — Enviando um comando para a máquina remota e recebendo uma resposta

      No cliente NKN Shell, digite seu endereço remoto nshd do Passo 1, bem como um identificador de cliente opcional:

      O site nsh com o endereço remoto preenchido

      Clique em Connect (Conectar) para iniciar a conexão.

      Você se conectará à sua máquina remota e será exibido um prompt de terminal dentro do navegador. A partir daqui, use-o da mesma forma que o SSH. Por exemplo, execute o comando a seguir para alternar para o diretório /etc/nshd:

      Então, liste o conteúdo do diretório:

      Você verá o conteúdo dele:

      Output

      authorized_pubkeys wallet.json wallet.pswd

      Desconecte-se digitando exit. Quando precisar se reconectar, visite novamente a interface Web e digite seus detalhes de conexão. Caso gere um novo par de chaves, será necessário adicionar a nova chave pública ao seu servidor.

      Conclusão

      Neste tutorial, você instalou e configurou o nsh para enviar comandos de maneira segura e conveniente para uma máquina remota. O nsh é uma ótima maneira de acessar suas máquinas remotas quando você precisa executar rapidamente um comando para obter o status mais recente de um serviço ou espiar algumas definições de configuração. O aplicativo se baseia na rede pública global da NKN e é gratuito para usar. Dessa forma, você pode incorporá-lo no seu próprio aplicativo ou fluxo de trabalho hoje.

      Também é possível explorar o nkn-tunnel, que é compatível com o SSH ou qualquer outro aplicativo baseado no TCP.



      Source link

      Cómo usar nsh para ejecutar comandos remotos seguros en Ubuntu 18.04


      Introducción

      A menudo, puede ser difícil administrar varios equipos diariamente. Aunque Scure Shell (SSH) es una buena opción para el acceso remoto, el protocolo en sí mismo tiene algunos inconvenientes en cuanto a practicidad y seguridad.

      Por ejemplo, los equipos remotos deben tener una dirección IP pública y un puerto reenviado para acceder a ellos, lo que los expone a Internet o al menos a una red más grande. Esto es, en particular, motivo de inquietud si utiliza una contraseña para la autenticación en vez de un par de claves pública y privada. Además, si no conoce la clave pública del equipo remoto con antelación, es posible que sea vulnerable a un ataque de “intermediario”. Muchos equipos remotos a los que quiere acceder no tienen una dirección IP pública o tienen una dirección IP dinámica que posiblemente no conozca.

      Además, SSH requiere una conexión por sesión remota. Si un usuario necesita ejecutar un único comando en cientos o incluso miles de máquinas, primero debe establecer una conexión con cada una mediante un protocolo de enlace TCP, que es menos eficiente.

      NKN Shell, o nsh, es una alternativa a SSH que proporciona una opción cómoda y segura para ejecutar comandos remotos. nsh aprovecha la red pública global de NKN que ofrece una transmisión de datos segura y descentralizada. La arquitectura utiliza direcciones únicas que contienen una clave pública usada para el direccionamiento y para el cifrado de extremo a extremo sin una infraestructura de claves públicas (PKI). La red tampoco requiere que el servidor remoto tenga una dirección IP pública. El servidor remoto solo necesita tener acceso a Internet y poder establecer conexiones HTTP y websocket salientes. Como resultado, sus equipos remotos no estarán expuestos a la Internet abierta.

      En este tutorial, usará el demonio de NKN Shell y las aplicaciones de NKN Shell Client Xterm para ejecutar comandos en un equipo remoto. Para hacerlo, instalará y configurará el demonio de NKN Shell en un equipo remoto con acceso a Internet, generará un par de claves y realizará su conexión desde un cliente.

      Requisitos previos

      Para seguir este tutorial, necesitará lo siguiente:

      Paso 1: Instalar el demonio de NKN Shell en un servidor remoto

      Primero, instale el demonio de NKN Shell (nsd) en su servidor. Esta aplicación invocará nkn-multiclient, que se conectará a la red pública de NKN y obtendrá una dirección para el direccionamiento. El demonio escuchará los comandos shell entrantes desde los clientes autenticados y de la lista blanca, ejecutará esos comandos y enviará resultados.

      Comience descargando el binario nshd previamente compilado desde GitHub:

      • wget https://github.com/nknorg/nkn-shell-daemon/releases/latest/download/linux-amd64.tar.gz

      Descomprima el archivo:

      • tar -zxvf linux-amd64.tar.gz

      Luego mueva los archivos al directorio /usr/local/bin a fin de que estén disponibles para todo el sistema:

      • sudo mv ./linux-amd64/* /usr/local/bin/

      A continuación, configurará esto para que se ejecute como un proceso de demonio usando Systemd, por lo que se reiniciará si se reinicia el servidor.

      Cree un archivo llamado nshd.service en /etc/systemd/system:

      • sudo nano /etc/systemd/system/nshd.service

      Añada la siguiente definición de servicio al archivo para configurar el servicio:

      /etc/systemd/system/nshd.service

      [Unit]
      Description=NKN Shell Daemon
      After=network.target
      
      [Service]
      Type=simple
      User=root
      Group=root
      Restart=always
      ExecStart=/usr/local/bin/nshd
      
      [Install]
      WantedBy=multi-user.target
      

      Encontrará más información sobre archivos de unidades de Systemd en Información sobre unidades y archivos de unidades de Systemd.

      Guarde el archivo y salga del editor. A continuación, habilite e inicie el servicio nshd con los siguientes comandos:

      • sudo systemctl enable nshd.service
      • sudo systemctl start nshd.service

      Ejecute el siguiente comando para garantizar que el servicio esté activo y se haya iniciado:

      • sudo systemctl status nshd.service

      Verá que se indica un estado activo:

      Output

      ● nshd.service - NKN Shell Daemon Loaded: loaded (/etc/systemd/system/nshd.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2020-02-19 19:16:02 UTC; 7s ago Main PID: 3457 (nshd) Tasks: 10 (limit: 1152) CGroup: /system.slice/nshd.service └─3457 /usr/local/bin/nshd Feb 19 19:16:02 your_hostname systemd[1]: Started NKN Shell Daemon. Feb 19 19:16:03 your_hostname nshd[3457]: Create directory /etc/nshd/ Feb 19 19:16:03 your_hostname nshd[3457]: Create password and save to file /etc/nshd/wallet.pswd Feb 19 19:16:03 your_hostname nshd[3457]: Create wallet and save to file /etc/nshd/wallet.json Feb 19 19:16:03 your_hostname nshd[3457]: Create authorized pubkeys file /etc/nshd/authorized_pubkeys Feb 19 19:16:03 your_hostname nshd[3457]: Listening at d46567b883a3070ee3fe879d9fa2d5dc55a95f79ff2797c42df36c6979e5c4Aba

      Para establecer conexión con su servidor, deberá obtener su dirección de NKN, que puede encontrar en el resultado del comando anterior. También puede ejecutar el siguiente comando para obtener la dirección:

      Verá que aparece su dirección:

      Output

      e70ca28ede84fc0659f2869255e8a393aef35b4fa5a7e036f29127c7dba75383

      Tome nota de esta dirección, ya que deberá establecer conexión con su servidor.

      Ahora que el demonio está en ejecución y escucha puede configurar el cliente basado en web para que se comunique con el servidor.

      Paso 2: Configurar permisos para NKN Shell Client

      Necesitará un cliente compatible que pueda conectar con el equipo remoto. Para este tutorial, usará NKN Shell Client Xterm, un cliente de NKN Shell basado en la Web. Hay varias formas diferentes de ejecutarlo:

      En este tutorial, usará la versión alojada. En su equipo local, abra su navegador web y diríjase a https://nsh.nkn.org. Verá una pantalla de bienvenida.

      El cliente Shell

      Haga clic en Generate New Key Pair​​. Sus claves se generarán y se mostrarán como en la siguiente imagen:

      El par de claves generado

      Nota: Cuando genere un nuevo par de claves, verá un valor de inicialización secreto. Mantenga seguro y protegido este valor de inicialización secreto, lo mismo que haría con su clave SSH privada. Cualquiera que tenga este valor de inicialización secreto puede usarlo para regenerar su clave pública y luego ejecutar los comandos en sus equipos remotos. Su navegador recordará este seed, pero debería hacer una copia de él en una ubicación segura de modo que pueda usarlo otra vez en un nuevo equipo.

      Guarde el Secret Seed en una ubicación segura. Puede usarlo más tarde para regenerar su clave pública de modo que pueda establecer conexión desde un equipo cliente diferente.

      Ya que este es un nuevo par de claves, debe añadir la Clave pública al archivo /etc/nshd/authorized_pubkeys en su servidor.

      /etc/nshd/authorized_pubkeys tiene un rol similar al del archivo ~/authorized_keys que controla las claves SSH públicas que pueden iniciar sesión. El archivo authorized_pubkeys puede especificar el usuario asociado con una clave. Por seguridad, querrá iniciar sesión usando un usuario no root en este tutorial, por lo cual asociará la clave pública generada con su usuario sammy que creó en la guía de Configuración inicial de servidores de los requisitos previos de este artículo.

      Para asociar un usuario con la clave pública, deberá obtener el ID de usuario (UID) y el ID de grupo (GID) de este usuario. Ejecute el siguiente comando en su servidor mientras la sesión esté iniciada con el usuario sammy:

      Verá el UID y el GID del usuario:

      Output

      uid=1000(sammy) gid=1000(sammy) groups=1000(sammy),27(sudo)

      Ahora, abra el archivo authorized_pubkeys en su editor:

      • sudo nano /etc/nshd/authorized_pubkeys

      Añada una línea única que contenga la clave pública, el uid y el gid separados por espacios:

      authorized_pubkeys

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000
      

      Guarde el archivo.

      Verifique que el contenido del archivo sea correcto:

      • cat /etc/nshd/authorized_pubkeys

      Verá su clave impresa en la pantalla:

      Output

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000

      A continuación reinicie el daemon nshd para aplicar los cambios:

      • sudo systemctl restart nshd.service

      Ahora, lo probaremos estableciendo conexión con el servidor y ejecutando un comando.

      Paso 3: Enviar un comando al equipo remoto y recibir una respuesta

      En NKN Shell Client, introduzca su dirección nshd remota del paso 1 y un identificador de cliente opcional:

      El sitio web nsh con la dirección remota completada en

      Haga clic en Connect para iniciar la conexión.

      Establecerá conexión con su equipo remoto y se mostrará una instrucción del terminal en el navegador. A partir de este punto, puede usarlo como SSH. Por ejemplo, ejecute el siguiente comando para pasar al directorio /etc/nshd:

      A continuación, liste su contenido:

      Verá el contenido del directorio:

      Output

      authorized_pubkeys wallet.json wallet.pswd

      Puede interrumpir la conexión escribiendo exit. Cuando necesite restablecer la conexión, vuelva a visitar la interfaz web e introduzca sus datos de conexión. Si genera un par de claves nuevo, deberá añadir la nueva clave pública a su servidor.

      Conclusión

      A través de este tutorial, instaló y configuró nsh para enviar de forma segura y cómoda comandos a un equipo remoto. nsh es una excelente alternativa para acceder a sus equipos remotos cuando necesita ejecutar rápidamente un comando para obtener el estado más reciente de un servicio o mirar algún ajuste de configuración. La aplicación se basa en la red pública global de NKN y es gratuita, de modo que puede incorporarla hoy a su aplicación o flujo de trabajo propios.

      También puede explorar nkn-tunnel, que admite SSH o cualquier otra aplicación basada en TCP.



      Source link

      Como Provisionar e Gerenciar Hosts Remotos do Docker com Docker Machine no Ubuntu 18.04


      Introdução

      Docker Machine é uma ferramenta que facilita o provisionamento e o gerenciamento de vários hosts Docker remotamente a partir do seu computador pessoal. Esses servidores são comumente chamados de hosts Dockerizados e são usados para executar containers do Docker.

      Embora o Docker Machine possa ser instalado em um sistema local ou remoto, a abordagem mais comum é instalá-lo em seu computador local (instalação nativa ou máquina virtual) e usá-lo para provisionar servidores remotos Dockerizados.

      Embora o Docker Machine possa ser instalado na maioria das distribuições Linux, bem como no MacOS e no Windows, neste tutorial, você o instalará em sua máquina local executando Ubuntu 18.04 e o usará para provisionar Droplets Dockerizados na DigitalOcean. Se você não tem uma máquina local Ubuntu 18.04, você pode seguir estas instruções em qualquer servidor Ubuntu 18.04.

      Pré-requisitos

      Para seguir este tutorial, você vai precisar do seguinte:

      • Uma máquina local ou servidor executando o Ubuntu 18.04 com o Docker instalado. Veja Como Instalar e Usar o Docker no Ubuntu 18.04 para instruções.

      • Um token de API da DigitalOcean. Se você não tiver um, gere-o usando este guia. Quando você gerar um token, certifique-se de que ele tenha um escopo de leitura e gravação. Esse é o padrão, portanto, se você não alterar nenhuma opção enquanto estiver gerando, ela terá recursos de leitura e gravação.

      Passo 1 — Instalando o Docker Machine

      Para usar a Docker Machine, você deve primeiro instalá-lo localmente. No Ubuntu, isso significa baixar um punhado de scripts do repositório oficial do Docker no GitHub.

      Para baixar e instalar o binário do Docker Machine, digite:

      • wget https://github.com/docker/machine/releases/download/v0.15.0/docker-machine-$(uname -s)-$(uname -m)

      O nome do arquivo deve ser docker-machine-Linux-x86_64. Renomeie-o para docker-machine para torná-lo mais fácil de trabalhar:

      • mv docker-machine-Linux-x86_64 docker-machine

      Torne-o executável:

      Mova ou copie-o para o diretório /usr/local/bin para que ele esteja disponível como um comando do sistema:

      • sudo mv docker-machine /usr/local/bin

      Verifique a versão, o que indicará que ele está corretamente instalado:

      Você verá uma saída semelhante a esta, exibindo o número da versão e a compilação:

      Output

      docker-machine version 0.15.0, build b48dc28d

      O Docker Machine está instalado. Vamos instalar algumas ferramentas auxiliares adicionais para facilitar o trabalho com o Docker Machine.

      Passo 2 — Instalando Scripts Adicionais do Docker Machine

      Existem três scripts Bash no repositório GitHub do Docker Machine que você pode instalar para facilitar o trabalho com os comandos docker e docker-machine. Quando instalados, esses scripts fornecem o recurso de auto-completar comandos e de personalização do prompt.

      Nesta etapa, você irá instalar esses três scripts no diretório /etc/bash_completion.d em sua máquina local, baixando-os diretamente do repositório GitHub do Docker Machine.

      Nota: Antes de baixar e instalar um script da internet em um local disponível do sistema, você deve inspecionar o conteúdo do script primeiro, visualizando a URL de origem em seu navegador.

      O primeiro script permite que você veja a máquina ativa no seu prompt. Isso é útil quando você está trabalhando e alternando entre várias máquinas Dockerizadas. O script é chamado de docker-machine-prompt.bash. Baixe-o

      • sudo wget https://raw.githubusercontent.com/docker/machine/master/contrib/completion/bash/docker-machine-prompt.bash -O /etc/bash_completion.d/docker-machine-prompt.bash

      Para completar a instalação deste arquivo, você terá que modificar o valor da variável PS1 no seu arquivo .bashrc. A variável PS1 é uma variável de shell especial usada para modificar o prompt de comando do Bash. Abra o ~/.bashrc em seu editor:

      Dentro desse arquivo, existem três linhas que começam com PS1. Elas devem se parecer com estas:

      ~/.bashrc

      
      PS1='${debian_chroot:+($debian_chroot)}[33[01;32m]u@h[33[00m]:[33[01;34m]w[33[00m]$ '
      
      ...
      
      PS1='${debian_chroot:+($debian_chroot)}u@h:w$ '
      
      ...
      
      PS1="[e]0;${debian_chroot:+($debian_chroot)}u@h: wa]$PS1"
      

      Para cada linha, insira $(__docker_machine_ps1 " [%s]") perto do final, conforme mostrado no exemplo a seguir:

      ~/.bashrc

      PS1='${debian_chroot:+($debian_chroot)}[33[01;32m]u@h[33[00m]:[33[01;34m]w[33[00m]$(__docker_machine_ps1 " [%s]")$ ' ... PS1='${debian_chroot:+($debian_chroot)}u@h:w$(__docker_machine_ps1 " [%s]")$ ' ... PS1="[e]0;${debian_chroot:+($debian_chroot)}u@h: wa]$(__docker_machine_ps1 " [%s]")$PS1"

      Salve e feche o arquivo.

      O segundo script é chamado de docker-machine-wrapper.bash. Ele adiciona um subcomando use ao comando docker-machine, facilitando significativamente a alternância entre os hosts Docker. Para baixá-lo, digite:

      • sudo wget https://raw.githubusercontent.com/docker/machine/master/contrib/completion/bash/docker-machine-wrapper.bash -O /etc/bash_completion.d/docker-machine-wrapper.bash

      O terceiro script é chamado de docker-machine.bash. Ele adiciona o auto-completar ao bash para os comandos docker-machine. Baixe-o usando:

      • sudo wget https://raw.githubusercontent.com/docker/machine/master/contrib/completion/bash/docker-machine.bash -O /etc/bash_completion.d/docker-machine.bash

      Para aplicar as alterações feitas até agora, feche e reabra seu terminal. Se você estiver logado na máquina via SSH, saia da sessão e faça o login novamente, e você terá o auto-completar de comandos para os comandos docker e docker-machine.

      Vamos testar as coisas criando um novo host Docker com o Docker Machine.

      Passo 3 — Provisionando um Host Dockerizado Usando o Docker Machine

      Agora que você tem o Docker e o Docker Machine em execução em sua máquina local, é possível provisionar um Droplet Dockerizado em sua conta da DigitalOcean usando o comando docker-machine create do Docker Machine. Se você ainda não o fez, atribua seu token da API da DigitalOcean a uma variável de ambiente:

      • export DOTOKEN=seu-token-de-api

      NOTA: Este tutorial usa DOTOKEN como a variável bash para o token da API da DigitalOcean. O nome da variável não precisa ser DOTOKEN e não precisa estar em maiúsculas.

      Para tornar a variável permanente, coloque-a em seu arquivo ~/.bashrc. Este passo é opcional, mas é necessário se você quiser que o valor persista entre sessões de shell.

      Abra esse arquivo com o nano:

      Adicione esta linha ao arquivo:

      ~/.bashrc

      export DOTOKEN=seu-token-de-api
      

      Para ativar a variável na sessão de terminal atual, digite:

      Para chamar o comando docker-machine create com sucesso, você deve especificar o driver que deseja usar, bem como o nome da máquina. O driver é o adaptador para a infraestrutura que você vai criar. Existem drivers para provedores de infraestrutura de nuvem, bem como drivers para várias plataformas de virtualização.

      Vamos usar o driver digitalocean. Dependendo do driver selecionado, você precisará fornecer opções adicionais para criar uma máquina. O driver digitalocean requer o token da API (ou a variável que o fornece) como seu argumento, junto com o nome da máquina que você deseja criar.

      Para criar sua primeira máquina, digite este comando para criar um Droplet na DigitalOcean chamado docker-01:

      • docker-machine create --driver digitalocean --digitalocean-access-token $DOTOKEN docker-01

      Você verá esta saída enquanto o Docker Machine cria o Droplet:

      Output

      ... Installing Docker... Copying certs to the local machine directory... Copying certs to the remote machine... Setting Docker configuration on the remote daemon... Checking connection to Docker... Docker is up and running! To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env ubuntu1804-docker

      O Docker Machine cria um par de chaves SSH para o novo host para que ele possa acessar o servidor remotamente. O Droplet é provisionado com um sistema operacional e o Docker é instalado. Quando o comando estiver concluído, o seu Droplet Docker estará em funcionamento.

      Para ver a máquina recém-criada a partir da linha de comando, digite:

      A saída será semelhante a esta, indicando que o novo host Docker está em execução:

      Output

      NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS docker-01 - digitalocean Running tcp://209.97.155.178:2376 v18.06.1-ce

      Agora vamos ver como especificar o sistema operacional quando criamos uma máquina.

      Passo 4 — Especificando o SO Básico e as Opções de Droplet ao Criar um Host Dockerizado

      Por padrão, o sistema operacional básico usado ao criar um host Dockerizado com o Docker Machine é supostamente o Ubuntu LTS mais recente. No entanto, no momento desta publicação, o comando docker-machine create ainda está usando o Ubuntu 16.04 LTS como o sistema operacional base, embora o Ubuntu 18.04 seja a edição mais recente do LTS. Portanto, se você precisar rodar o Ubuntu 18.04 em uma máquina recém-provisionada, você terá que especificar o Ubuntu junto com a versão desejada passando a flag --digitalocean-image para o comandodocker-machine create.

      Por exemplo, para criar uma máquina usando o Ubuntu 18.04, digite:

      • docker-machine create --driver digitalocean --digitalocean-image ubuntu-18-04-x64 --digitalocean-access-token $DOTOKEN docker-ubuntu-1804

      Você não está limitado a uma versão do Ubuntu. Você pode criar uma máquina usando qualquer sistema operacional suportado na DigitalOcean. Por exemplo, para criar uma máquina usando o Debian 8, digite:

      • docker-machine create --driver digitalocean --digitalocean-image debian-8-x64 --digitalocean-access-token $DOTOKEN docker-debian

      Para provisionar um host Dockerizado usando o CentOS 7 como o SO base, especifique centos-7-0-x86 como o nome da imagem, da seguinte forma:

      • docker-machine create --driver digitalocean --digitalocean-image centos-7-0-x64 --digitalocean-access-token $DOTOKEN docker-centos7

      O sistema operacional básico não é a única opção que você tem. Você também pode especificar o tamanho do Droplet. Por padrão, é o menor Droplet, que tem 1 GB de RAM, uma única CPU e um SSD de 25 GB.

      Encontre o tamanho do Droplet que você deseja usar procurando o slug correspondente na documentação da API da DigitalOcean.

      Por exemplo, para provisionar uma máquina com 2 GB de RAM, duas CPUs e um SSD de 60 GB, use o slug s-2vcpu-2gb:

      docker-machine create --driver digitalocean --digitalocean-size s-2vcpu-2gb --digitalocean-access-token $DOTOKEN docker-03
      

      Para ver todas as flags específicas para criar um Docker Machine usando o driver da DigitalOcean, digite:

      • docker-machine create --driver digitalocean -h

      Dica: Se você atualizar a página de Droplet do seu painel da DigitalOcean, verá as novas máquinas que você criou usando o comando docker-machine.

      Agora vamos explorar alguns dos outros comandos do Docker Machine.

      Passo 5 — Executando Comandos Adicionais do Docker Machine

      Você viu como provisionar um host Dockerizado usando o subcomando create e como listar os hosts disponíveis para o Docker Machine usando o subcomando ls. Nesta etapa, você aprenderá alguns subcomandos mais úteis.

      Para obter informações detalhadas sobre um host Dockerizado, use o subcomando inspect, da seguinte forma:

      • docker-machine inspect docker-01

      A saída inclui linhas como as da saída mostrada abaixo. A linha Image revela a versão da distribuição Linux usada, e a linha Size indica o slug do tamanho:

      Output

      ... { "ConfigVersion": 3, "Driver": { "IPAddress": "203.0.113.71", "MachineName": "docker-01", "SSHUser": "root", "SSHPort": 22, ... "Image": "ubuntu-16-04-x64", "Size": "s-1vcpu-1gb", ... }, ---

      Para imprimir a configuração de conexão de um host, digite:

      • docker-machine config docker-01

      A saída será smelhante a esta:

      Output

      --tlsverify --tlscacert="/home/kamit/.docker/machine/certs/ca.pem" --tlscert="/home/kamit/.docker/machine/certs/cert.pem" --tlskey="/home/kamit/.docker/machine/certs/key.pem" -H=tcp://203.0.113.71:2376

      A última linha na saída do comando docker-machine config revela o endereço IP do host, mas você também pode obter essa informação digitando:

      • docker-machine ip docker-01

      Se você precisar desligar um host remoto, você pode usar docker-machine para pará-lo:

      • docker-machine stop docker-01

      Verifique se está parado:

      A saída mostra que o status da máquina mudou:

      Ouput

      NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS docker-01 - digitalocean Stopped Unknown

      Para iniciá-la novamente, use o subcomando start:

      • docker-machine start docker-01

      Em seguida, revise seu status novamente:

      Você verá que o STATE agora está definido como Running para o host:

      Ouput

      NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS docker-01 - digitalocean Running tcp://203.0.113.71:2376 v18.06.1-ce

      Em seguida, vamos ver como interagir com o host remoto usando o SSH.

      Passo 6 — Executando Comandos em um Host Dockerizado via SSH

      Neste ponto, você está recebendo informações sobre suas máquinas, mas você pode fazer mais do que isso. Por exemplo, você pode executar comandos nativos do Linux em um host Docker usando o subcomando ssh do docker-machine a partir do seu sistema local. Esta seção explica como executar comandos ssh via docker-machine, bem como abrir uma sessão SSH para um host Dockerizado.

      Supondo que você provisionou uma máquina com o Ubuntu como sistema operacional, execute o seguinte comando em seu sistema local para atualizar o banco de dados de pacotes no host Docker:

      • docker-machine ssh docker-01 apt-get update

      Você pode até mesmo aplicar atualizações disponíveis usando:

      • docker-machine ssh docker-01 apt-get upgrade

      Não tem certeza de qual kernel seu host Docker remoto está usando? Digite o seguinte:

      • docker-machine ssh docker-01 uname -r

      Finalmente, você pode efetuar login no host remoto com o comando docker machine ssh:

      • docker-machine ssh docker-01

      Você estará logado como usuário root e verá algo semelhante ao seguinte:

      Welcome to Ubuntu 16.04.5 LTS (GNU/Linux 4.4.0-131-generic x86_64)
      
       * Documentation:  https://help.ubuntu.com
       * Management:     https://landscape.canonical.com
       * Support:        https://ubuntu.com/advantage
      
        Get cloud support with Ubuntu Advantage Cloud Guest:
          http://www.ubuntu.com/business/services/cloud
      
      14 packages can be updated.
      10 updates are security updates.
      

      Faça o logout digitando exit para retornar à sua máquina local.

      Em seguida, direcionaremos comandos do Docker em nosso host remoto.

      Passo 7 — Ativando um Host Dockerizado

      A ativação de um host Docker conecta seu cliente Docker local a esse sistema, o que possibilita a execução de comandos docker comuns no sistema remoto.

      Primeiro, use o Docker Machine para criar um novo host do Docker chamado docker-ubuntu usando o Ubuntu 18.04:

      • docker-machine create --driver digitalocean --digitalocean-image ubuntu-18-04-x64 --digitalocean-access-token $DOTOKEN docker-ubuntu

      Para ativar um host Docker, digite o seguinte comando:

      • eval $(docker-machine env machine-name)

      Alternativamente, você pode ativá-lo usando este comando:

      • docker-machine use machine-name

      Uma dica ao trabalhar com vários hosts Docker, é que o comando docker-machine use é o método mais fácil de alternar de um para o outro.

      Depois de digitar qualquer um desses comandos, seu prompt será alterado para indicar que o cliente Docker está apontando para o host do Docker remoto. Ele terá essa forma. O nome do host estará no final do prompt:

      username@localmachine:~ [docker-01]$
      

      Agora, qualquer comando docker que você digitar neste prompt de comando será executado naquele host remoto.

      Execute docker-machine ls novamente:

      Você verá um asterisco sob a coluna ACTIVE para docker-01:

      Output

      NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS docker-01 * digitalocean Running tcp://203.0.113.71:2376 v18.06.1-ce

      Para sair do host Docker remoto, digite o seguinte:

      Seu prompt não mostrará mais o host ativo.

      Agora vamos criar containers na máquina remota.

      Passo 8 — Criando Containers Docker em um Host Dockerizado Remoto

      Até agora, você provisionou um Droplet Dockerizado na sua conta DigitalOcean e o ativou — ou seja, seu cliente Docker está apontando para ele. O próximo passo lógico é criar containers nele. Por exemplo, vamos tentar executar o container Nginx oficial.

      Utilize docker-machine use para selecionar sua máquina remota:

      • docker-machine use docker-01

      Em seguida, execute este comando para executar um container Nginx nessa máquina:

      • docker run -d -p 8080:80 --name httpserver nginx

      Neste comando, estamos mapeando a porta 80 no container Nginx para a porta 8080 no host Dockerizado para que possamos acessar a página padrão do Nginx de qualquer lugar.

      Depois que o container for construído, você poderá acessar a página padrão do Nginx apontando seu navegador para http://docker_machine_ip:8080.

      Enquanto o host Docker ainda estiver ativado (conforme visto pelo seu nome no prompt), você poderá listar as imagens nesse host:

      A saída inclui a imagem Nginx que você acabou de usar:

      • Output
      • REPOSITORY TAG IMAGE ID CREATED SIZE
      • nginx latest 71c43202b8ac 3 hours ago 109MB

      Você também pode listar os containers ativos ou em execução no host:

      Se o container Nginx que você executou nesta etapa for o único container ativo, a saída ficará assim:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES d3064c237372 nginx "nginx -g 'daemon of…" About a minute ago Up About a minute 0.0.0.0:8080->80/tcp httpserver

      Se você pretende criar containers em uma máquina remota, seu cliente Docker deve estar apontando para ele — isto é, deve ser a máquina ativa no terminal que você está usando. Caso contrário, você estará criando o container em sua máquina local. Novamente, deixe seu prompt de comando ser seu guia.

      O Docker Machine pode criar e gerenciar hosts remotos e também pode removê-los.

      Passo 9 – Removendo Hosts Docker

      Você pode usar o Docker Machine para remover um host Docker que você criou. Use o comando docker-machine rm para remover o host docker-01 que você criou:

      • docker-machine rm docker-01

      O Droplet é excluído junto com a chave SSH criada para ele. Liste os hosts novamente:

      Desta vez, você não verá o host docker-01 listado na saída. E se você criou apenas um host, você não verá saída alguma.

      Certifique-se de executar o comando docker-machine use -u para apontar seu daemon do Docker local de volta para sua máquina local.

      Passo 10 — Desativando o Relatório de Falhas (Opcinal)

      Por padrão, sempre que uma tentativa de provisionar um host Dockerizado usando o Docker Machine falha, ou o Docker Machine trava, algumas informações de diagnóstico são enviadas para uma conta Docker em Bugsnag. Se você não está confortável com isso, você pode desabilitar o relatório criando um arquivo vazio chamado no-error-report no diretório .docker/machine do seu computador local.

      Para criar o arquivo, digite:

      • touch ~/.docker/machine/no-error-report

      Verifique o arquivo em busca de mensagens de erro para falhas de provisionamento ou travamento do Docker Machine.

      Conclusão

      Você instalou o Docker Machine e o usou para provisionar vários hosts Docker na DigitalOcean remotamente a partir do seu sistema local. A partir daqui, você deve ser capaz de provisionar quantos hosts Dockerizados forem necessários em sua conta DigitalOcean.

      Para mais informações sobre o Docker Machine, visite a página de documentação oficial. Os três scripts Bash baixados neste tutorial estão hospedados nessa página do GitHub.

      Por finid e Brian Hogan



      Source link