One place for hosting & domains

      comandos

      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 Usar o Doctl, o Cliente de Linha de comandos Oficial da DigitalOcean


      Uma versão anterior deste tutorial foi escrita por Brennen Bearnes.

      Introdução

      O painel de controle web da DigitalOcean fornece uma interface de gerenciamento de Droplets usando apontar e clicar . No entanto, você pode preferir uma ferramenta de linha de comando se tiver muitos Droplets para gerenciar, precisar administrar Droplets a partir do terminal sem uma área de trabalho gráfica disponível ou tiver tarefas que se beneficiariam de uma interface com script.

      doctl é o cliente oficial de linha de comandos da DigitalOcean. Ele utiliza a API da DigitalOcean para fornecer acesso à maioria dos recursos da conta e dos Droplets.

      Pré-requisitos

      Para seguir este tutorial, você precisará de:

      Este tutorial pretende ser uma referência para a maioria das operações do doctl. Como os comandos doctl são intimamente ligados à API, também pode ser útil ler a documentação da API e Como Usar a API da DigitalOcean v2.

      Uso Genérico do doctl

      Executando Comandos

      No doctl, os recursos individuais são executados, fornecendo ao utilitário um comando, um ou mais subcomandos e, às vezes, uma ou mais opções que especificam valores particulares. Os comandos são agrupados em três categorias principais:

      • account para informações relacionadas à conta
      • auth para autenticação com a DigitalOcean
      • compute para o gerenciamento de infraestrutura

      Para ver uma visão geral de todos os comandos, você pode chamar o doctl por si só. Para ver todos os comandos disponíveis em uma das três categorias principais, você pode usar doctl categoria, como doctl compute. Para um guia de uso de um comando específico, digite o comando com a flag --help, como em doctl compute droplet --help.

      Recuperando Dados no Formato JSON

      Em ambientes de script, ou ao trabalhar na linha de comando com ferramentas de processamento de dados, geralmente é útil obter uma saída legível por máquina a partir de um comando.

      Por padrão, o doctl formata sua saída em colunas de texto legível por humanos, mas pode produzir uma saída JSON detalhada usando a opção --output json.

      • doctl compute droplet get droplet_id --output json

      Sample Output

      { "id": droplet_id, "name": "nome_do_droplet", "memory": 1024, "vcpus": 1, "disk": 30, "region": { "slug": "nyc3", "name": "New York 3", "sizes": [ ...

      Além de ser um formato legível com bibliotecas padrão na maioria das linguagens de programação, a saída JSON pode permitir uma inspeção mais detalhada dos Droplets e de outros recursos.

      Formatação

      Geralmente, é útil obter apenas um conjunto de campos da saída. Para fazer isso, você pode usar a flag --format, que pega a lista de campos pelo seu nome. Por exemplo, se você deseja obter apenas o ID, nome e endereço IP dos seus Droplets, você pode usar o seguinte comando:

      • doctl compute droplet list --format "ID,Name,PublicIPv4"

      Sample output

      ID Name Public IPv4 50513569 doctl-1 67.205.152.65 50513570 test 67.205.148.128 50513571 node-1 67.205.131.88

      Templates

      O comando doctl compute droplet get suporta template de saída, o que lhe permite personalizar o formato da saída. Para usar esse recurso, especifique o template formatado para Go via a flag --template

      Por exemplo, se você deseja obter o nome de um Droplet no formato droplet_name: nome_do_droplet, use o seguinte comando get:

      • doctl compute droplet get 12345678 --template "nome_do_droplet: {{ .Name}}"

      Output

      nome_do_droplet: ubuntu-1gb-nyc3-01

      Listando Recursos

      Para obter uma lista de recursos, como Droplets, você pode usar o comando list sem parâmetros.

      • doctl compute droplet list

      Sample output for list command

      ID Name Public IPv4 Private IPv4 Public IPv6 Memory VCPUs Disk Region Image Status Tags 50513569 test-1 67.205.152.65 512 1 20 nyc1 Ubuntu 16.04.2 x64 active 50513571 test-2 67.205.131.88 512 1 20 nyc1 Ubuntu 16.04.2 x64 active 50513570 site 67.205.148.128 512 1 20 nyc1 Ubuntu 16.04.2 x64 active

      O comando list suporta um glob como um parâmetro opcional. Um glob representa um padrão com caracteres curinga que podem ser usados para filtrar recursos específicos por nome. Por exemplo, para obter uma lista de Droplets cujos nomes começam com test, você pode usar o seguinte comando:

      doctl compute droplet list 'test*'
      

      Sample output for list command with 'doctl-' as glob

      ID Name Public IPv4 Private IPv4 Public IPv6 Memory VCPUs Disk Region Image Status Tags 50513569 test-1 67.205.152.65 512 1 20 nyc1 Ubuntu 16.04.2 x64 active 50513571 test-2 67.205.131.88 512 1 20 nyc1 Ubuntu 16.04.2 x64 active

      Criando Recursos

      Criar um recurso requer comandos mais longos com parâmetros mais detalhados. Para criar um Droplet, você precisará especificar a imagem que deseja usar, a região do datacenter e o tipo de Droplet que deseja usando o slug associado. Veja New Size Slugs for Droplet Plan Changes
      para encontrar o slug que você quer usar. Como alternativa, execute o comando doctl compute size list.

      Por exemplo, o comando a seguir cria um Droplet Debian 8 de 64 bits chamado test com 1 GB de memória, uma CPU, uma chave SSH e backups ativados.

      • doctl compute droplet create test --size s-1vcpu-1gb --image debian-8-x64 --region nyc1 --ssh-keys 4d:23:e6:e4:8c:17:d2:cf:89:47:36:b5:c7:33:40:4e --enable-backups

      Você verá esta saída:

      Sample Droplet creation output

      ID Name Public IPv4 Memory VCPUs Disk Region Image Status 11450164 test 1024 1 30 nyc1 Debian 8.3 x64 new

      A exclusão de um recurso requer um ID de recurso como argumento ou um nome de recurso no caso de não existir um ID para determinado recurso (por exemplo, tags). Para confirmar suas intenções, você precisa confirmar todas as ações de exclusão, respondendo à pergunta de confirmação com y ou yes.

      doctl compute droplet delete 123456
      

      Output

      Warning: Are you sure you want to delete droplet(s) (y/N) ?

      Não fornecer uma resposta ou fornecer uma resposta diferente de y ou yes cancelará a ação sem excluir o recurso. Você pode fazer com que o doctl assuma uma resposta afirmativa sem fornecê-la explicitamente, usando a flag -f (--force):

      doctl compute droplet delete -f 123456
      

      Localizando Identificadores Exclusivos para Recursos

      O comando de criação de Droplets requer uma série de identificadores, como nyc1 para a região NYC1, debian-8-x64 para a imagem Debian e uma impressão digital ou fingerprint da chave SSH como 4d:23:e6:e4:8c:17:d2:cf:89:47:36:b5:c7:33:40:4e.

      Vários recursos, como Droplets e imagens, são identificados por um valor (geralmente numérico) exclusivo no banco de dados da DigitalOcean.

      Você pode obter os identificadores exclusivos necessários para a maioria dos comandos da API:

      Comando Notas
      doctl compute droplet list Seus Droplets. Alguns comandos também levam o nome; a maioria exige o valor numérico da coluna ID.
      doctl compute ssh-key list As chaves SSH associadas à sua conta. Para a criação de Droplets, você pode especificar o ID numérico ou fingerprint.
      doctl compute region list Regiões disponíveis. Use a string na coluna Slug.
      doctl compute image list Imagens disponíveis, incluindo snapshots, backups e imagens base de distribuição. Use a string na coluna Slug para a criação de novos Droplets.
      doctl compute size list Tamanhos de Droplets disponíveis. Use a string na coluna Slug.
      doctl compute tag list Tags disponíveis. Use a string na coluna Name.

      Criando, Excluindo, e Inspecionando Droplets

      O comando doctl compute droplet lhe permite criar, excluir e inspecionar Droplets. Novamente, a maioria dos comandos para trabalhar com Droplets individuais exige o ID exclusivo do Droplet, e estes podem ser encontrados na saída do comando doctl droplet list.

      Subcomando doctl compute droplet Notas
      actions droplet_id Exibir um histórico de ações executadas para um Droplet.
      backups droplet_id Listar backups para um Droplet.
      create name --size s-1vcpu-1gb --image image_slug --region nyc1 Criar um Droplet. Tamanho, imagem e região são todos obrigatórios.
      delete droplet_id_ou_nome Excluir um Droplet por ID ou nome.
      get droplet_id Obter detalhes de um Droplet específico.
      kernels droplet_id Listar kernels para um Droplet.
      list Listar seus Droplets atuais.
      neighbors droplet_id Listar seus Droplets em execução no mesmo hardware físico que um Droplet específico.
      snapshots droplet_id Listar snapshots para um Droplet.
      tag droplet_id/nome_do_droplet Colocar uma Tag em um Droplet.
      untag droplet_id/nome_do_droplet Retirar uma tag de um Droplet.

      Iniciando Ações em Droplets

      O comando doctl compute droplet-action lhe permite disparar várias ações para um Droplet, incluindo ações de gerenciamento de energia e alternância de recursos como backups e redes privadas.

      Subcomando doctl compute droplet-action Notas
      get droplet_id --action-id action_id Obter detalhes sobre a ação em um Droplet.
      disable-backups droplet_id Desativar backups para um Droplet.
      reboot droplet_id Reiniciar um Droplet.
      power-cycle droplet_id Desligar e ligar novamente um Droplet.
      shutdown droplet_id Desligar um Droplet.
      power-off droplet_id Desligar um Droplet. O Droplet deve estar ligado. Geralmente, é melhor fazer isso na linha de comando do próprio Droplet para evitar perda de dados.
      power-on droplet_id Ligue um Droplet. O Droplet deve estar desligado.
      power-reset droplet_id Resetar um Droplet.
      enable-ipv6 droplet_id Ativar ipv6 para um Droplet.
      enable-private-networking droplet_id Ativar rede privada para um Droplet.
      upgrade droplet_id Fazer upgrade de um Droplet.
      restore droplet_id --image-id image_id Restaurar um Droplet para uma imagem de backup específica. O image_id deve ser um backup do Droplet.
      resize droplet_id --size 2gb Redimensionar um Droplet. O Droplet deve estar desligado. Por padrão, o disco não é redimensionado, o que permite que o Droplet seja rebaixado. Você pode redimensionar o disco usando a flag --resize-disk.
      rebuild droplet_id --image-id image_id Reconstruir um Droplet a partir de uma imagem específica.
      rename droplet_id --droplet-name novo_nome Renomear um Droplet para novo_nome.
      change-kernel droplet_id --kernel-id kernel_id Alterar o kernel de um Droplet para kernel_id.
      snapshot droplet_id --snapshot-name nome_do_snapshot Tirar um instantâneo ou snapshot de um Droplet, nomeando-o como nome_do_snapshot.

      Fazendo Conexões SSH

      Para se conectar a um Droplet individual com SSH, geralmente é necessário saber seu endereço IP ou nome de domínio totalmente qualificado. Você pode usar o doctl para se conectar a um Droplet pelo seu nome, ID numérico ou IP privado:

      • doctl compute ssh nome_do_droplet
      • doctl compute ssh droplet_id
      • doctl compute ssh --ssh-private-ip ip_privado_do_droplet

      Além disso, você pode fornecer um comando para executar assim que a conexão SSH for estabelecida usando a flag --ssh-command. Isso executará o comando, cuja saída será impressa no seu terminal local, e então a sessão SSH será fechada.

      • doctl compute ssh --ssh-command comando

      Nota: No momento, o encaminhamento de comandos SSH não está disponível no Windows.

      O nome do usuário SSH padrão é root (core para o CoreOS) e a porta padrão é a 22. Você pode usar flags para definir valores não padrão e ativar outros recursos:

      Flag Descrição
      --ssh-user string Nome de usuário a ser usado para a sessão SSH.
      --ssh-port int A porta para a sessão SSH.
      --ssh-key-path string Caminho para a chave SSH.
      --ssh-agent-forwarding Ativar encaminhamento de agente.

      Você também pode alterar os valores de configuração padrão em um arquivo de configuração. O arquivo README do projeto tem mais detalhes sobre como fazer isso.

      Usando Chaves SSH

      Você pode gerenciar as chaves públicas SSH associadas à sua conta usando o comando doctl compute ssh-key. A maioria dos comandos que fazem referência às chaves SSH aceitam o ID numérico da chave ou sua fingerprint.

      Subcomando doctl compute ssh-key Notas
      list Listar chaves SSH associadas à sua conta.
      get ssh_key_id_ou_fingerprint Obter informações sobre uma chave específica, por ID numérico ou fingerprint da chave.
      create novo_nome_da_chave --public-key "chave_pública" Associar uma chave pública à sua conta, especificando seu conteúdo.
      import novo_nome_da_chave --public-key-file ~/.ssh/id_rsa.pub Associar uma chave pública à sua conta especificando um arquivo de origem.
      delete ssh_key_id_ou_fingerprint Excluir uma chave da sua conta por ID numérico ou fingerprint.
      update ssh_key_id_ou_fingerprint --key-name novo_nome_da_chave Alterar o nome de uma chave por ID numérico ou fingerprint.

      Um IP flutuante é um endereço IP estático acessível ao público que pode ser atribuído a um de seus Droplets. Para uma descrição detalhada do recurso, você pode ler Como usar IPs flutuantes na DigitalOcean. Você pode manipular IPs flutuantes com doctl compute floating-ip.

      Subcomando doctl compute floating-ip Notas
      list Listar todos os endereços IP flutuantes.
      get endereço_ip_flutuante Obter detalhes de um endereço IP flutuante.
      create --region nyc1 Crie um IP flutuante na região nyc1.
      delete endereço_ip_flutuante Excluir um endereço IP flutuante.

      Atribuir IPs Flutuantes aos Droplets

      O comando doctl compute floating-ip-action é usado para atribuir ou cancelar a atribuição de um IP flutuante de um Droplet.

      Subcomando doctl compute floating-ip-action Notas
      assign ip_flutuante droplet_id Atribuir um IP flutuante ao Droplet pelo seu ID numérico.
      unassign ip_flutuante Cancelar a atribuição de um IP flutuante.
      get ip_flutuante action_id Obter detalhes sobre uma ação de IP flutuante pelo seu ID numérico.

      Trabalhando com Domains

      O comando doctl compute domain é usado para gerenciar domínios. Veja nossa Série de Introdução ao gerenciamento de DNS para uma visão geral mais ampla do assunto.

      Subcomando doctl compute domain Notas
      list Listar domínios.
      create nome_de_domínio --ip-address endereço_ip_do_droplet Criar um domínio com registros padrão para endereço_ip_do_droplet.
      get nome_de_domínio Obter um registro de domínio.
      delete nome_de_domínio Excluir um domínio.

      Gerenciando Registros de Domínio

      O comando doctl compute domain records pode ser usado para criar, excluir, atualizar ou obter informações sobre os registros DNS do domínio.

      Subcomando doctl compute domain records Notas
      list nome_de_domínio Listar registros para determinado domínio.
      create nome_de_domínio --record-type tipo_de_registro Criar um registro para o domínio.
      delete nome_de_domínio record_id Excluir registro pelo ID numérico.
      update nome_de_domínio --record-id record_id Atualizar registro pelo ID numérico.

      Criando, Excluindo e Inspecionando Volumes de Armazenamento em Bloco

      O comando doctl compute volume pode ser usado para criar, excluir ou obter informações sobre os volumes de armazenamento em bloco da DigitalOcean. Para obter mais informações sobre esse recurso, leia nosso guia Como usar o armazenamento em bloco na DigitalOcean.

      Subcomando doctl compute volume Notas
      list Listar volumes.
      create nome_do_volume --region região_do_volume --size tamanho_do_volume Criar um volume. O nome, região e tamanho são obrigatórios.
      get volume_ID Obter volume pelo ID numérico.
      delete volume_ID Excluir volume.
      snapshot volume_ID Fazer um Snapshot de um volume.

      Iniciando Ações de Volume

      O comando doctl compute volume-action lhe permite disparar ações para um volume, incluindo anexar volumes e desanexar volumes de Droplets.

      Subcomando doctl compute volume-action Notas
      attach volume_id droplet_id Anexar um volume a um Droplet.
      detach volume_id droplet_id Desanexar um volume de um Droplet.
      resize volume_id --region região_do_volume --size novo_tamanho Redimensionar um volume.

      O comando doctl compute load-balancer pode ser usado para criar, excluir ou obter informações sobre os balanceadores de carga ou Load Balancers da DigitalOcean. Para obter mais informações sobre esse recurso, leia nossa Introdução aos balanceadores de carga da DigitalOcean.

      Subcomando doctl compute load-balancer Notas
      list Listar load balancers.
      create --name nome_do_lb --region região_do_lb --tag-name nome_da_tag --forwarding-rules regra_de_encaminhamento Criar um Load Balancer. O nome, a região, uma tag ou lista de IDs de Droplets e pelo menos uma regra de encaminhamento são obrigatórios.
      update --name nome_do_lb --region região_do_lb --tag-name nome_da_tag --forwarding-rules regra_de_encaminhamento Atualizar um Load Balancer. O nome, a região, uma tag ou lista de IDs de Droplets e pelo menos uma regra de encaminhamento são obrigatórios.
      get lb_ID Obter um load balancer pelo ID.
      delete lb_ID Excluir um load balancer pelo ID.
      add-droplets lb_ID --droplet-ids droplet_ID Adicionar Droplets a um load balancer.
      remove-droplets lb_ID --droplet-ids droplet_ID Remover Droplets de um load balancer.
      add-forwarding-rules lb_ID --forwarding-rules regra_de_encaminhamento Adicionar regras de encaminhamento a um load balancer.
      remove-forwarding-rules lb_ID --forwarding-rules regra_de_encaminhamento Remover regras de encaminhamento de um load balancer.

      Quando usado como argumento para o doctl, as regras de encaminhamento devem ser expressas como: entry_protocol:protocolo,entry_port:porta,target_protocol:protocolo,target_port:porta.

      Gerenciando Certificados

      O subcomando doctl compute certificate lhe permite fazer upload e gerenciar certificados SSL, chaves privadas e cadeias de certificados.

      Subcomando doctl compute certificate Notas
      list Listar todos os certificados.
      get certificate_id Obter um certificado pelo ID.
      create --name nome_do_certificado --leaf-certificate-path caminho_do_cetrificado_em_folha Criar um certificado. O nome e o caminho do certificado em folha são obrigatórios.
      delete certificate_id Excluir um certificado pelo ID.

      O comando doctl compute snapshot pode ser usado para listar, excluir ou obter informações sobre snapshots de Droplet e de Volume.

      Subcomando doctl compute snapshot Notas
      list Listar todos os Snapshots.
      get snapshot_ID Obter um Snapshot pelo ID.
      delete snapshot_ID Excluir um Snapshot.

      Para criar um novo Snapshot, você precisa usar o comando apropriado na árvore de comandos do recurso relevante. Por exemplo:

      • doctl compute droplet-action snapshot droplet_ID cria um Snapshot de um Droplet.
      • doctl compute volume snapshot volume_ID cria um Snapshot de um Volume.

      O comando doctl compute image lhe permite gerenciar todas as imagens, incluindo imagens de distribuição, imagens de aplicações e imagens criadas pelo usuário, como backups e snapshots. Recomendamos o uso do comando snapshot para gerenciar snapshots, pois ele fornece mais detalhes, possui funcionalidade de exclusão e suporta snapshots de Armazenamento em Bloco.

      Subcomando doctl compute image Notas
      list --public Listar todas imagens.
      list-distribution --public Listar todas imagens de distribuição disponíveis
      list-application --public Listar todas as imagens de Aplicações de Um Clique.
      list-user Listar todas as imagens criadas pelo usuário.
      get image_id Obter uma imagem pelo ID.
      update image_id --name nome_da_imagem Atualizar o nome da imagem. O nome é obrigatório.
      delete image_id Excluir uma imagem pelo ID.

      Chamando Ações de Imagens

      O comando doctl compute image-action lhe permite transferir imagens e obter detalhes sobre as ações invocadas nas imagens.

      Subcomando doctl compute image-action Notas
      get image_id --action-id action_id Obter uma ação para a imagem pelo seu ID. O ID da ação é obrigatório.
      transfer image_id --region região Transferir uma imagem para outra região. O ID da imagem e a região são obrigatórios.

      O comando doctl compute firewall lhe permite criar e gerenciar Firewalls, incluindo a criação e a manutenção de regras. Para obter mais informações sobre como administrar Firewalls usando o doctl, consulte o tutorial How To Secure Web Server Infrastructure With DigitalOcean Cloud Firewalls Using Doctl.

      Comando doctl compute firewall Notas
      list Listar todos os Firewalls.
      list-by-droplet droplet_id Listar todos os Firewalls pelo ID numérico do Droplet.
      create --name nome_do_firewall --inbound-rules regras_de_entrada --outbound-rules regras_de_saída Criar um Firewall. O nome e pelo menos uma regra de entrada ou saída são obrigatórios.
      update firewall_id --name nome_do_firewall --inbound-rules regras_de_entrada --outbound-rules regras_de_saída Atualizar um Firewall. O ID numérico, o nome e pelo menos uma regra de entrada ou saída são obrigatórios.
      get firewall_id Obter um Firewall pelo seu ID numérico.
      delete firewall_id Excluir um firewall pelo ID numérico.
      add-droplets firewall_id --droplet-ids droplet_IDs Adicionar Droplets pelo seu ID numérico ao Firewall.
      remove-droplets firewall_id --droplet-ids droplet_IDs Remover Droplets do Firewall pelos seus IDs numéricos.
      add-tags firewall_id --tag-names tags Adicionar Tags ao Firewall.
      remove-tags firewall_id --tag-names tags Remover Tags do Firewall.
      add-rules firewall_id --inbound-rules regras_de_entrada --outbound-rules regras_de_saída Adicionar regras de entrada ou saída ao Firewall.
      remove-rules firewall_id --inbound-rules regras_de_entrada --outbound-rules regras_de_saída Remover as regras de entrada ou saída do Firewall.

      Quando usado como argumento para o doctl, as regras de entrada ou saída devem ser expressas como: protocol:protocolo,ports:portas,droplet_id:droplet-id.

      As Tags são usadas para aplicar rótulos personalizados aos recursos, permitindo que você os filtre facilmente. Você pode aprender mais sobre Tags no tutorial How To Tag DigitalOcean Droplets.

      Subcomando doctl compute tag Notas
      create nome_da_tag Criar uma Tag.
      get nome_da_tag Obter uma Tag pelo nome.
      list Listar todas as Tags.
      delete nome_da_tag Excluir uma Tag pelo nome.

      Lendo o Histórico de Ações da sua Conta

      O sistema da DigitalOcean registra um histórico das ações executadas em seus Droplets, IPs flutuantes e outros recursos. Você pode acessar esses dados com o comando doctl compute action:

      • doctl compute action list

      Você pode ver ações para um Droplet específico da seguinte maneira:

      • doctl compute droplet actions droplet_id

      Recuperando Informações da sua Conta

      Você pode descobrir detalhes básicos sobre sua conta, como seu endereço de e-mail configurado e o limite de Droplet:

      Como as solicitações de API são limitadas por uma taxa de acessos, pode ser útil ver quantas solicitações você fez recentemente e quando o limite deve ser redefinido:

      Conclusão

      O utilitário doctl é uma ferramenta útil para gerenciar Droplets e outros recursos na linha de comando. Isso pode reduzir bastante a quantidade de interação manual com interfaces baseadas em web, necessárias para tarefas diárias de desenvolvimento e de administração.

      Além de aprender sobre a API subjacente, você pode querer explorar bibliotecas que envolvem a API para linguagens de programação populares, e ferramentas como Ansible para automatizar tarefas no nível do sistema.



      Source link