Introdução
O SSH é um protocolo seguro usado como o principal meio de conexão com servidores Linux remotamente. Ele fornece uma interface baseada em texto, gerando um shell remoto. Após a conexão, todos os comandos que você digita no seu terminal local são enviados para o servidor remoto e executados lá.
Neste guia no estilo de folha de dicas, vamos cobrir algumas maneiras comuns de conectar-se com SSH para alcançar seus objetivos. Isso pode ser usado como uma referência rápida quando você precisa saber como se conectar ou configurar seu servidor de diferentes maneiras.
Implante suas aplicações frontend do GitHub usando Plataforma de Aplicativos da DigitalOcean. Deixe a DigitalOcean focar em escalar seu aplicativo.
Como Usar Este Guia
- Leia a seção Visão Geral do SSH primeiro se você não estiver familiarizado com SSH em geral ou estiver apenas começando.
- Use as seções subsequentes que forem aplicáveis ao que você está tentando alcançar. A maioria das seções não é baseada em nenhuma outra, então você pode usar os exemplos a seguir de forma independente.
- Use o menu de conteúdo no lado esquerdo desta página (em larguras de página amplas) ou a função de pesquisa do seu navegador para localizar as seções que você precisa.
- Copie e cole os exemplos de linha de comando dados, substituindo os valores
destacadospelos seus próprios valores.
Visão Geral do SSH
A maneira mais comum de se conectar a um servidor Linux remoto é através do SSH. SSH significa Secure Shell e fornece uma maneira segura de executar comandos, fazer alterações e configurar serviços remotamente. Quando você se conecta através do SSH, faz login usando uma conta que existe no servidor remoto.
Como o SSH Funciona
Ao se conectar através do SSH, você será inserido em uma sessão de shell, que é uma interface baseada em texto onde você pode interagir com seu servidor. Durante toda a sua sessão SSH, quaisquer comandos que você digitar no seu terminal local são enviados através de um túnel SSH criptografado e executados no seu servidor.
A conexão SSH é implementada usando um modelo cliente-servidor. Isso significa que, para uma conexão SSH ser estabelecida, a máquina remota deve estar executando um software chamado daemon SSH. Esse software escuta conexões em uma porta de rede específica, autentica solicitações de conexão e inicia o ambiente apropriado se o usuário fornecer as credenciais corretas.
O computador do usuário deve ter um cliente SSH. Este é um software que sabe como se comunicar usando o protocolo SSH e pode receber informações sobre o host remoto ao qual se conectar, o nome de usuário a ser usado e as credenciais que devem ser passadas para autenticação. O cliente também pode especificar detalhes sobre o tipo de conexão que deseja estabelecer.
Como o SSH autentica usuários
Os clientes geralmente se autenticam usando senhas (menos seguro e não recomendado) ou chaves SSH, que são muito seguras.
Os logins por senha são criptografados e são fáceis de entender para novos usuários. No entanto, bots automatizados e usuários maliciosos frequentemente tentarão autenticar-se repetidamente em contas que permitem logins baseados em senha, o que pode levar a comprometimentos de segurança. Por esse motivo, recomendamos sempre configurar a autenticação baseada em chaves SSH para a maioria das configurações.
As chaves SSH são um conjunto correspondente de chaves criptográficas que podem ser usadas para autenticação. Cada conjunto contém uma chave pública e uma chave privada. A chave pública pode ser compartilhada livremente sem preocupações, enquanto a chave privada deve ser guardada com vigilância e nunca exposta a ninguém.
Para autenticar usando chaves SSH, um usuário deve ter um par de chaves SSH em seu computador local. No servidor remoto, a chave pública deve ser copiada para um arquivo dentro do diretório pessoal do usuário em ~/.ssh/authorized_keys. Este arquivo contém uma lista de chaves públicas, uma por linha, que estão autorizadas a fazer login nesta conta.
Quando um cliente se conecta ao host, desejando usar autenticação por chave SSH, ele informará ao servidor dessa intenção e dirá ao servidor qual chave pública usar. O servidor então verifica seu arquivo authorized_keys para a chave pública, gera uma sequência aleatória e a criptografa usando a chave pública. Esta mensagem criptografada só pode ser descriptografada com a chave privada associada. O servidor enviará esta mensagem criptografada para o cliente para testar se eles realmente têm a chave privada associada.
Ao receber esta mensagem, o cliente a descriptografa usando a chave privada e combina a sequência aleatória revelada com um ID de sessão previamente negociado. Em seguida, ele gera um hash MD5 desse valor e o transmite de volta para o servidor. O servidor já tinha a mensagem original e o ID de sessão, então pode comparar um hash MD5 gerado por esses valores e determinar que o cliente deve ter a chave privada.
Agora que você sabe como o SSH funciona, podemos começar a discutir alguns exemplos para demonstrar diferentes maneiras de trabalhar com o SSH.
Gerar e Trabalhar com Chaves SSH
Esta seção abordará como gerar chaves SSH em um computador cliente e distribuir a chave pública para servidores onde elas devem ser utilizadas. Esta é uma boa seção para começar se você ainda não gerou chaves anteriormente devido à segurança aumentada que ela permite para conexões futuras.
Gerando um Par de Chaves SSH
Gerar um novo par de chaves pública e privada SSH em seu computador local é o primeiro passo para autenticar-se com um servidor remoto sem uma senha. A menos que haja uma boa razão para não fazê-lo, você sempre deve autenticar-se usando chaves SSH.
A number of cryptographic algorithms can be used to generate SSH keys, including RSA, DSA, and ECDSA. RSA keys are generally preferred and are the default key type.
Para gerar um par de chaves RSA em seu computador local, digite:
Generating public/private rsa key pair.
Enter file in which to save the key (/home/demo/.ssh/id_rsa):
Este prompt permite que você escolha o local para armazenar sua chave privada RSA. Pressione ENTER para deixar isso como padrão, que irá armazená-las no diretório oculto .ssh no diretório principal do seu usuário. Deixar o local padrão selecionado permitirá que seu cliente SSH encontre as chaves automaticamente.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
A próxima etapa permite que você insira uma frase secreta de comprimento arbitrário para proteger sua chave privada. Por padrão, você terá que inserir qualquer frase secreta que definir aqui toda vez que usar a chave privada, como uma medida de segurança adicional. Sinta-se à vontade para pressionar ENTER para deixar isso em branco se você não desejar uma frase secreta. No entanto, tenha em mente que isso permitirá que qualquer pessoa que obtenha controle de sua chave privada faça login em seus servidores.
Se optar por inserir uma frase secreta, nada será exibido enquanto você digita. Isso é uma precaução de segurança.
OutputYour identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
8c:e9:7c:fa:bf:c4:e5:9c:c9:b8:60:1f:fe:1c:d3:8a root@here
The key's randomart image is:
+--[ RSA 2048]----+
| |
| |
| |
| + |
| o S . |
| o . * + |
| o + = O . |
| + = = + |
| ....Eo+ |
+-----------------+
Este procedimento gerou um par de chaves SSH RSA, localizado no diretório oculto .ssh dentro do diretório pessoal do seu usuário. Esses arquivos são:
~/.ssh/id_rsa: A chave privada. NÃO COMPARTILHE ESTE ARQUIVO!~/.ssh/id_rsa.pub: A chave pública associada. Esta pode ser compartilhada livremente sem consequências.
Gerar um Par de Chaves SSH com um Maior Número de Bits
As chaves SSH têm 2048 bits por padrão. Isso geralmente é considerado suficiente para segurança, mas você pode especificar um número maior de bits para uma chave mais fortificada.
Para fazer isso, inclua o argumento -b com o número de bits desejado. A maioria dos servidores suporta chaves com um comprimento de pelo menos 4096 bits. Chaves mais longas podem não ser aceitas por motivos de proteção contra DDOS:
Se você tiver criado anteriormente uma chave diferente, será perguntado se deseja substituir sua chave anterior:
Overwrite (y/n)?
Se você escolher “sim”, sua chave anterior será substituída e você não poderá mais fazer login nos servidores usando essa chave. Por causa disso, certifique-se de substituir as chaves com cuidado.
Removendo ou Alterando a Frase de Senha de uma Chave Privada
Se você gerou uma frase de senha para sua chave privada e deseja alterá-la ou removê-la, você pode fazer isso facilmente.
Observação: Para alterar ou remover a frase de senha, você deve conhecer a frase de senha original. Se você perdeu a frase de senha da chave, não há recurso e você terá que gerar um novo par de chaves.
Para alterar ou remover a frase de senha, basta digitar:
Enter file in which the key is (/root/.ssh/id_rsa):
Você pode digitar o local da chave que deseja modificar ou pressionar ENTER para aceitar o valor padrão:
Enter old passphrase:
Digite a antiga frase de senha que deseja alterar. Você será solicitado a digitar uma nova frase de senha:
Enter new passphrase (empty for no passphrase):
Enter same passphrase again:
Aqui, digite sua nova frase de senha ou pressione ENTER para remover a frase de senha.
Exibindo a Impressão Digital da Chave SSH
Cada par de chaves SSH compartilha uma única “impressão digital” criptográfica que pode ser usada para identificar as chaves de forma única. Isso pode ser útil em várias situações.
Para descobrir a impressão digital de uma chave SSH, digite:
Enter file in which the key is (/root/.ssh/id_rsa):
Você pode pressionar ENTER se essa for a localização correta da chave, caso contrário, insira a localização revisada. Você receberá uma string que contém o comprimento do bit da chave, a impressão digital, a conta e o host para os quais foi criada, e o algoritmo usado:
Output4096 8e:c4:82:47:87:c2:26:4b:68:ff:96:1a:39:62:9e:4e demo@test (RSA)
Copiando sua Chave SSH Pública para um Servidor com SSH-Copy-ID
Para copiar sua chave pública para um servidor, permitindo que você se autentique sem uma senha, várias abordagens podem ser tomadas.
Se você atualmente tem acesso SSH baseado em senha configurado para o seu servidor, e você tem a utilidade ssh-copy-id instalada, este é um processo simples. A ferramenta ssh-copy-id está incluída em muitos pacotes OpenSSH de distribuições Linux, então é muito provável que esteja instalada por padrão.
Se você tiver essa opção, pode transferir facilmente sua chave pública digitando:
Isso solicitará a senha da conta de usuário no sistema remoto:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
[email protected]'s password:
Depois de digitar a senha, o conteúdo da sua chave ~/.ssh/id_rsa.pub será anexado ao final do arquivo ~/.ssh/authorized_keys da conta de usuário:
OutputNumber of key(s) added: 1
Now try logging into the machine, with: "ssh '[email protected]'"
and check to make sure that only the key(s) you wanted were added.
Agora é possível fazer login naquela conta sem uma senha:
Copiando sua Chave Pública SSH para um Servidor Sem SSH-Copy-ID
Se você não tiver o utilitário ssh-copy-id disponível, mas ainda tiver acesso SSH baseado em senha para o servidor remoto, você pode copiar o conteúdo da sua chave pública de uma maneira diferente.
Você pode imprimir o conteúdo da chave e direcioná-lo para o comando ssh. Do lado remoto, você pode garantir que o diretório ~/.ssh exista e, em seguida, anexar o conteúdo direcionado ao arquivo ~/.ssh/authorized_keys:
Você será solicitado a fornecer a senha da conta remota:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
[email protected]'s password:
Depois de inserir a senha, sua chave será copiada, permitindo que você faça login sem uma senha:
Copiando sua Chave Pública SSH para um Servidor Manualmente
Se você não tiver acesso SSH baseado em senha disponível, precisará adicionar sua chave pública ao servidor remoto manualmente.
Em sua máquina local, você pode encontrar o conteúdo do seu arquivo de chave pública digitando:
Outputssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCqql6MzstZYh1TmWWv11q5O3pISj2ZFl9HgH1JLknLLx44+tXfJ7mIrKNxOOwxIxvcBF8PXSYvobFYEZjGIVCEAjrUzLiIxbyCoxVyle7Q+bqgZ8SeeM8wzytsY+dVGcBxF6N4JS+zVk5eMcV385gG3Y6ON3EG112n6d+SMXY0OEBIcO6x+PnUSGHrSgpBgX7Ks1r7xqFa7heJLLt2wWwkARptX7udSq05paBhcpB0pHtA1Rfz3K2B+ZVIpSDfki9UVKzT8JUmwW6NNzSgxUfQHGwnW7kj4jp4AT0VZk3ADw497M2G/12N0PPB5CnhHf7ovgy6nL1ikrygTKRFmNZISvAcywB9GVqNAVE+ZHDSCuURNsAInVzgYo9xgJDW8wUw2o8U77+xiFxgI5QSZX3Iq7YLMgeksaO4rBJEa54k8m5wEiEE1nUhLuJ0X/vh2xPff6SQ1BL/zkOhvJCACK6Vb15mDOeCSq54Cr7kvS46itMosi/uS66+PujOO+xt/2FWYepz6ZlN70bRly57Q06J+ZJoc9FfBCbCyYH7U/ASsmY095ywPsBo1XQ9PqhnN1/YOorJ068foQDNVpm146mUpILVxmq41Cj55YKHEazXGsdBIbXWhcrRf4G2fJLRcGUr9q8/lERo9oxRm5JFX6TCmj6kmiFqv+Ow9gI0x8GvaQ== demo@test
Você pode copiar este valor e colá-lo manualmente no local apropriado no servidor remoto. Você terá que fazer login no servidor remoto por outros meios (como o console web da DigitalOcean).
No servidor remoto, crie o diretório ~/.ssh se ele ainda não existir:
Depois, você pode criar ou adicionar ao arquivo ~/.ssh/authorized_keys digitando:
Agora você deve conseguir fazer login no servidor remoto sem senha.
Instruções Básicas de Conexão
A próxima seção abordará alguns conceitos básicos sobre como se conectar a um servidor com SSH.
Conectando a um Servidor Remoto
Para se conectar a um servidor remoto e abrir uma sessão de terminal lá, você pode usar o comando ssh.
A forma mais simples assume que seu nome de usuário em sua máquina local é o mesmo que no servidor remoto. Se isso for verdade, você pode se conectar usando:
Se seu nome de usuário for diferente no servidor remoto, você precisa passar o nome do usuário remoto assim:
Sua primeira vez conectando-se a um novo host, você verá uma mensagem que se parece com esta:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
Digite sim para aceitar a autenticidade do host remoto.
Se estiver usando autenticação por senha, será solicitada a senha da conta remota aqui. Se estiver usando chaves SSH, será solicitada a frase secreta da sua chave privada, se uma estiver configurada, caso contrário, você será conectado automaticamente.
Executando um Único Comando em um Servidor Remoto
Para executar um único comando em um servidor remoto em vez de iniciar uma sessão de shell, você pode adicionar o comando após as informações de conexão, assim:
Isso se conectará ao host remoto, autenticará com suas credenciais e executará o comando especificado. A conexão será encerrada imediatamente depois.
Fazendo Login em um Servidor com uma Porta Diferente
Por padrão, o daemon SSH em um servidor é executado na porta 22. Seu cliente SSH assumirá que este é o caso ao tentar se conectar. Se o seu servidor SSH estiver ouvindo em uma porta não padrão (isso é demonstrado em uma seção posterior), você terá que especificar o novo número da porta ao conectar com seu cliente.
Você pode fazer isso especificando o número da porta com a opção -p:
Para evitar ter que fazer isso toda vez que você acessa o seu servidor remoto, você pode criar ou editar um arquivo de configuração no diretório ~/.ssh dentro do diretório pessoal do seu computador local.
Edite ou crie o arquivo agora digitando:
Aqui, você pode definir opções de configuração específicas do host. Para especificar a nova porta, use um formato como este:
Host remote_alias
HostName remote_host
Port port_num
Isso permitirá que você faça login sem especificar o número da porta específica na linha de comando.
Adicionando suas chaves SSH a um Agente SSH para Evitar Digitar a Frase de Senha
Se você tiver uma frase de senha em sua chave SSH privada, será solicitado que você insira a frase de senha sempre que a usar para se conectar a um host remoto.
Para evitar ter que fazer isso repetidamente, você pode executar um agente SSH. Este pequeno utilitário armazena sua chave privada depois que você inseriu a frase de senha pela primeira vez. Ela estará disponível durante a sessão do seu terminal, permitindo que você se conecte no futuro sem precisar inserir a frase de senha novamente.
Isso também é importante se você precisar encaminhar suas credenciais SSH (mostrado posteriormente).
Para iniciar o Agente SSH, digite o seguinte na sua sessão de terminal local:
OutputAgent pid 10891
Isso iniciará o programa do agente e o colocará em segundo plano. Agora, você precisa adicionar sua chave privada ao agente, para que ele possa gerenciar sua chave:
Enter passphrase for /home/demo/.ssh/id_rsa:
Identity added: /home/demo/.ssh/id_rsa (/home/demo/.ssh/id_rsa)
Você terá que inserir sua frase secreta (se estiver definida). Depois, seu arquivo de identidade é adicionado ao agente, permitindo que você use sua chave para fazer login sem ter que inserir a frase secreta novamente.
Encaminhando suas Credenciais SSH para Usar em um Servidor
Se você deseja poder se conectar sem uma senha a um servidor de dentro de outro servidor, precisará encaminhar as informações da sua chave SSH. Isso permitirá que você se autentique em outro servidor por meio do servidor ao qual está conectado, usando as credenciais do seu computador local.
Para começar, você deve ter seu agente SSH iniciado e sua chave SSH adicionada ao agente (veja anteriormente). Depois disso, você precisa se conectar ao seu primeiro servidor usando a opção -A. Isso encaminha suas credenciais para o servidor para esta sessão:
A partir daqui, você pode fazer SSH para qualquer outro host que sua chave SSH esteja autorizada a acessar. Você se conectará como se sua chave SSH privada estivesse localizada neste servidor.
Opções de Configuração do Lado do Servidor
Esta seção contém algumas opções comuns de configuração do lado do servidor que podem moldar a forma como o seu servidor responde e que tipos de conexões são permitidas.
Desativando Autenticação por Senha
Se você tiver chaves SSH configuradas, testadas e funcionando corretamente, provavelmente é uma boa ideia desativar a autenticação por senha. Isso evitará que qualquer usuário faça login com SSH usando uma senha.
Para fazer isso, conecte-se ao seu servidor remoto e abra o arquivo /etc/ssh/sshd_config com privilégios de root ou sudo:
Dentro do arquivo, procure pela diretiva PasswordAuthentication. Se estiver comentada, descomente-a. Defina-a como não para desativar os logins por senha:
PasswordAuthentication no
Depois de fazer a alteração, salve e feche o arquivo. Para implementar as alterações, você deve reiniciar o serviço SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Agora, todas as contas no sistema não poderão fazer login com SSH usando senhas.
Alterando a Porta em que o Daemon SSH Opera
Alguns administradores sugerem que você altere a porta padrão na qual o SSH é executado. Isso pode ajudar a diminuir o número de tentativas de autenticação às quais seu servidor é submetido por bots automatizados.
Para alterar a porta na qual o daemon SSH escuta, você precisará fazer login no seu servidor remoto. Abra o arquivo sshd_config no sistema remoto com privilégios de root, seja fazendo login com esse usuário ou usando sudo:
Assim que estiver dentro, você pode alterar a porta na qual o SSH é executado localizando a especificação Port 22 e modificando-a para refletir a porta que deseja usar. Por exemplo, para mudar a porta para 4444, coloque isso no seu arquivo:
#Port 22
Port 4444
Salve e feche o arquivo quando terminar. Para implementar as alterações, você deve reiniciar o daemon SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Depois que o daemon for reiniciado, você precisará se autenticar especificando o número da porta (demonstrado em uma seção anterior).
Limitando os Usuários que Podem se Conectar via SSH
Para limitar explicitamente as contas de usuário que podem fazer login através do SSH, você pode adotar algumas abordagens diferentes, todas as quais envolvem a edição do arquivo de configuração do daemon SSH.
No seu servidor remoto, abra este arquivo agora com privilégios de root ou sudo:
O primeiro método de especificar as contas que estão autorizadas a fazer login é usando a diretiva AllowUsers. Procure pela diretiva AllowUsers no arquivo. Se ela não existir, crie-a em qualquer lugar. Após a diretiva, liste as contas de usuário que devem ser permitidas a fazer login através do SSH:
AllowUsers user1 user2
Salve e feche o arquivo. Reinicie o daemon para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Se você se sentir mais confortável com o gerenciamento de grupos, pode usar a diretiva AllowGroups em vez disso. Nesse caso, adicione apenas um grupo que deve ter acesso SSH (vamos criar este grupo e adicionar membros em breve):
AllowGroups sshmembers
Salve e feche o arquivo.
Agora, você pode criar um grupo de sistema (sem diretório home) correspondente ao grupo que especificou digitando:
Certifique-se de adicionar as contas de usuário necessárias a este grupo. Isso pode ser feito digitando:
Agora, reinicie o daemon SSH para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Desativando o Login do Root
É frequentemente recomendável desativar completamente o login do root através do SSH depois de configurar uma conta de usuário SSH que tenha privilégios de sudo.
Para fazer isso, abra o arquivo de configuração do daemon SSH com root ou sudo no seu servidor remoto.
Dentro, procure por uma diretiva chamada PermitRootLogin. Se estiver comentada, descomente-a. Mude o valor para “no”:
PermitRootLogin no
Salve e feche o arquivo. Para implementar suas alterações, reinicie o daemon SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Permitindo Acesso Root para Comandos Específicos
Há casos em que você pode querer desabilitar o acesso root em geral, mas ativá-lo para permitir que certos aplicativos funcionem corretamente. Um exemplo disso pode ser uma rotina de backup.
Isso pode ser feito através do arquivo authorized_keys do usuário root, que contém chaves SSH autorizadas a usar a conta.
Adicione a chave do seu computador local que deseja usar para este processo (recomendamos criar uma nova chave para cada processo automático) ao arquivo authorized_keys do usuário root no servidor. Demonstraremos com o comando ssh-copy-id aqui, mas você pode usar qualquer um dos métodos de cópia de chaves que discutimos em outras seções:
Agora, faça login no servidor remoto. Precisaremos ajustar a entrada no arquivo authorized_keys, então abra-o com acesso de root ou sudo:
No início da linha com a chave que você enviou, adicione um command= listando o comando para o qual essa chave é válida. Isso deve incluir o caminho completo para o executável, além de quaisquer argumentos:
command="/path/to/command arg1 arg2" ssh-rsa ...
Salve e feche o arquivo quando terminar.
Agora, abra o arquivo sshd_config com privilégios de root ou sudo:
Encontre a diretiva PermitRootLogin e altere o valor para forced-commands-only. Isso permitirá apenas logins de chave SSH para usar o root quando um comando for especificado para a chave:
PermitRootLogin forced-commands-only
Salve e feche o arquivo. Reinicie o daemon SSH para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Encaminhamento de Exibição de Aplicativos X para o Cliente
O daemon SSH pode ser configurado para encaminhar automaticamente a exibição de aplicativos X no servidor para a máquina cliente. Para que isso funcione corretamente, o cliente deve ter um sistema de janelas X configurado e ativado.
Para habilitar essa funcionalidade, faça login no seu servidor remoto e edite o arquivo sshd_config como root ou com privilégios de sudo:
Procure pela diretiva X11Forwarding. Se estiver comentada, descomente-a. Crie-a se necessário e defina o valor como “yes”:
X11Forwarding yes
Salvar e fechar o arquivo. Reinicie o daemon SSH para implementar essas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Para se conectar ao servidor e encaminhar a exibição de um aplicativo, você deve passar a opção -X do cliente durante a conexão:
Aplicações gráficas iniciadas no servidor através desta sessão devem ser exibidas no computador local. O desempenho pode ser um pouco lento, mas é muito útil em momentos de necessidade.
Opções de Configuração do Lado do Cliente
Na próxima seção, vamos focar em alguns ajustes que você pode fazer no lado do cliente da conexão.
Definindo Informações de Conexão Específicas do Servidor
No seu computador local, você pode definir configurações individuais para alguns ou todos os servidores aos quais você se conecta. Estas podem ser armazenadas no arquivo ~/.ssh/config, que é lido pelo seu cliente SSH cada vez que é chamado.
Crie ou abra este arquivo no seu editor de texto no seu computador local:
Dentro, você pode definir opções de configuração individuais introduzindo cada uma com uma palavra-chave Host, seguida de um alias. Abaixo disso e indentado, você pode definir qualquer uma das diretivas encontradas na página do manual ssh_config:
Um exemplo de configuração seria:
Host testhost
HostName your_domain
Port 4444
User demo
Você poderia então se conectar a seu_domínio na porta 4444 usando o nome de usuário demo simplesmente digitando:
Você também pode usar curingas para corresponder a mais de um host. Tenha em mente que correspondências posteriores podem substituir as anteriores. Por causa disso, você deve colocar as correspondências mais gerais no topo. Por exemplo, você poderia definir todas as conexões como não permitindo o encaminhamento X, com uma substituição para seu_domínio tendo isto no seu arquivo:
Host *
ForwardX11 no
Host testhost
HostName your_domain
ForwardX11 yes
Port 4444
User demo
Salve e feche o arquivo quando terminar.
Mantendo as Conexões Ativas para Evitar Timeouts
Se você se encontrar sendo desconectado de sessões SSH antes de estar pronto, é possível que sua conexão esteja expirando.
Você pode configurar seu cliente para enviar um pacote para o servidor de vez em quando para evitar essa situação:
No seu computador local, você pode configurar isso para cada conexão editando seu arquivo ~/.ssh/config. Abra-o agora:
Se uma seção ainda não existir, no topo do arquivo, defina uma seção que corresponderá a todos os hosts. Defina o ServerAliveInterval para “120” para enviar um pacote para o servidor a cada dois minutos. Isso deve ser suficiente para notificar o servidor a não fechar a conexão:
Host *
ServerAliveInterval 120
Salve e feche o arquivo quando terminar.
Desativando a Verificação de Host
Por padrão, sempre que você se conectar a um novo servidor, será mostrada a impressão digital da chave do host do daemon SSH remoto.
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
Isso é configurado para que você possa verificar a autenticidade do host ao qual está tentando se conectar e detectar casos em que um usuário mal-intencionado pode estar tentando se passar pelo host remoto.
Em certas circunstâncias, você pode desejar desativar esse recurso. Nota: Isso pode ser um grande risco de segurança, então certifique-se de saber o que está fazendo se configurar seu sistema dessa maneira.
Para fazer a alteração, abra o arquivo ~/.ssh/config no seu computador local:
Se uma seção ainda não existir, no topo do arquivo, defina uma seção que corresponderá a todos os hosts. Defina a diretiva StrictHostKeyChecking para no para adicionar automaticamente novos hosts ao arquivo known_hosts. Defina o UserKnownHostsFile para /dev/null para não avisar sobre hosts novos ou alterados:
Host *
StrictHostKeyChecking no
UserKnownHostsFile /dev/null
Você pode habilitar a verificação caso a caso revertendo essas opções para outros hosts. O padrão para StrictHostKeyChecking é ask:
Host *
StrictHostKeyChecking no
UserKnownHostsFile /dev/null
Host testhost
HostName your_domain
StrictHostKeyChecking ask
UserKnownHostsFile /home/demo/.ssh/known_hosts
Multiplexação SSH em uma Única Conexão TCP
Há situações em que estabelecer uma nova conexão TCP pode levar mais tempo do que o desejado. Se você estiver fazendo múltiplas conexões para a mesma máquina, pode aproveitar a multiplexação.
A multiplexação SSH reutiliza a mesma conexão TCP para várias sessões SSH. Isso elimina parte do trabalho necessário para estabelecer uma nova sessão, possivelmente acelerando as coisas. Limitar o número de conexões também pode ser útil por outros motivos.
Para configurar a multiplexação, você pode configurar manualmente as conexões ou pode configurar seu cliente para usar automaticamente a multiplexação quando disponível. Demonstraremos a segunda opção aqui.
Para configurar a multiplexação, edite o arquivo de configuração do cliente SSH em sua máquina local:
Se você ainda não tiver uma definição de host curinga no topo do arquivo, adicione uma agora (como Host *). Estaremos definindo os valores ControlMaster, ControlPath e ControlPersist para estabelecer nossa configuração de multiplexação.
O ControlMaster deve ser definido como “auto” para permitir automaticamente a multiplexação, se possível. O ControlPath estabelecerá o caminho para o socket de controle. A primeira sessão criará este socket e as sessões subsequentes poderão encontrá-lo porque ele é rotulado pelo nome de usuário, host e porta.
Definir a opção ControlPersist como 1 permitirá que a conexão mestre inicial seja colocada em segundo plano. O 1 especifica que a conexão TCP deve ser encerrada automaticamente um segundo após o fechamento da última sessão SSH:
Host *
ControlMaster auto
ControlPath ~/.ssh/multiplex/%r@%h:%p
ControlPersist 1
Salve e feche o arquivo quando terminar. Agora, precisamos realmente criar o diretório especificado no caminho de controle:
Agora, quaisquer sessões estabelecidas com a mesma máquina tentarão usar o socket e a conexão TCP existentes. Quando a última sessão for encerrada, a conexão será desativada após um segundo.
Se por algum motivo você precisar ignorar temporariamente a configuração de multiplexação, pode fazer isso passando a bandeira -S com none:
Configurando Túneis SSH
Tunelar outros tráfegos através de um túnel SSH seguro é uma excelente maneira de contornar configurações restritivas de firewall. Também é uma ótima maneira de criptografar o tráfego de rede que, de outra forma, não estaria criptografado.
Configurando Tunelamento Local para um Servidor
As conexões SSH podem ser usadas para tunelar o tráfego de portas no host local para portas em um host remoto.
A local connection is a way of accessing a network location from your local computer through your remote host. First, an SSH connection is established to your remote host. On the remote server, a connection is made to an external (or internal) network address provided by the user and traffic to this location is tunneled to your local computer on a specified port.
Isso é frequentemente usado para tunelar para um ambiente de rede menos restrito, contornando um firewall. Outro uso comum é acessar uma interface web “somente local” de um local remoto.
Para estabelecer um túnel local para seu servidor remoto, você precisa usar o parâmetro -L ao se conectar e deve fornecer três informações adicionais:
- A porta local onde deseja acessar a conexão tunelada.
- O host ao qual você deseja que seu host remoto se conecte.
- A porta à qual você deseja que seu host remoto se conecte.
Esses são fornecidos, na ordem acima (separados por dois pontos), como argumentos para a flag -L. Também usaremos a flag -f, que faz com que o SSH entre em segundo plano antes de executar, e a flag -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para se conectar a seu_domínio na porta 80 em seu host remoto, tornando a conexão disponível em sua máquina local na porta 8888, você poderia digitar:
Agora, se você apontar seu navegador web local para 127.0.0.1:8888, você deverá ver o conteúdo que está em seu_domínio na porta 80.
A more general guide to the syntax is:
Uma vez que a conexão está em segundo plano, você precisará encontrar o PID para encerrá-la. Você pode fazer isso pesquisando a porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -L 8888:your_domain:80 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Em seguida, você pode encerrar o processo direcionando o PID, que é o número na segunda coluna da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a bandeira -f. Isso manterá a conexão em primeiro plano, impedindo-o de usar a janela do terminal durante o encaminhamento. O benefício disso é que você pode encerrar o túnel facilmente digitando CTRL-C.
Configurando o Encaminhamento Remoto para um Servidor
As conexões SSH podem ser usadas para encaminhar o tráfego de portas no host local para portas em um host remoto.
Em um túnel remoto, uma conexão é feita com um host remoto. Durante a criação do túnel, uma porta remota é especificada. Esta porta, no host remoto, então será encaminhada para uma combinação de host e porta que está conectada a partir do computador local. Isso permitirá que o computador remoto acesse um host através do seu computador local.
Isso pode ser útil se você precisar permitir o acesso a uma rede interna que está bloqueada para conexões externas. Se o firewall permitir conexões de saída da rede, isso permitirá que você se conecte a uma máquina remota e encaminhe o tráfego dessa máquina para um local na rede interna.
Para estabelecer um túnel remoto para o seu servidor remoto, você precisa usar o parâmetro -R ao se conectar e deve fornecer três informações adicionais:
- A porta onde o host remoto pode acessar a conexão tunelada.
- O host ao qual você deseja que o seu computador local se conecte.
- A porta à qual você deseja que o seu computador local se conecte.
Esses são fornecidos, na ordem acima (separados por dois pontos), como argumentos para a flag -R. Também vamos usar a flag -f, que faz com que o SSH entre em segundo plano antes de executar, e a flag -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para se conectar ao seu_domínio na porta 80 no nosso computador local, tornando a conexão disponível no nosso host remoto na porta 8888, você poderia digitar:
Agora, no host remoto, abrir um navegador da web para 127.0.0.1:8888 permitiria ver qualquer conteúdo em seu_domínio na porta 80.
A more general guide to the syntax is:
Como a conexão está em segundo plano, você terá que encontrar o seu PID para encerrá-la. Você pode fazer isso procurando a porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -R 8888:your_domain:80 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Você pode então encerrar o processo direcionando o PID, que é o número na segunda coluna, da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a bandeira -f. Isso manterá a conexão em primeiro plano, impedindo você de usar a janela do terminal durante o encaminhamento. O benefício disso é que você pode encerrar facilmente o túnel digitando CTRL-C.
Configurando o Encaminhamento Dinâmico para um Servidor Remoto
As conexões SSH podem ser usadas para encaminhar o tráfego de portas no host local para portas em um host remoto.
A dynamic tunnel is similar to a local tunnel in that it allows the local computer to connect to other resources through a remote host. A dynamic tunnel does this by simply specifying a single local port. Applications that wish to take advantage of this port for tunneling must be able to communicate using the SOCKS protocol so that the packets can be correctly redirected at the other side of the tunnel.
O tráfego passado para esta porta local será enviado para o host remoto. A partir daí, o protocolo SOCKS será interpretado para estabelecer uma conexão com o local final desejado. Esta configuração permite que um aplicativo compatível com SOCKS se conecte a qualquer número de locais por meio do servidor remoto, sem túneis estáticos múltiplos.
Para estabelecer a conexão, passaremos a bandeira -D junto com a porta local onde desejamos acessar o túnel. Também usaremos a bandeira -f, que faz com que o SSH entre em segundo plano antes de executar, e a bandeira -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para estabelecer um túnel na porta 7777, você pode digitar:
A partir daqui, você pode começar a apontar seu aplicativo compatível com SOCKS (como um navegador da web) para a porta selecionada. O aplicativo enviará suas informações para um socket associado à porta.
O método de direcionar o tráfego para a porta SOCKS será diferente dependendo da aplicação. Por exemplo, no Firefox, a localização geral é Preferências > Avançado > Configurações > Configurações manuais de proxy. No Chrome, você pode iniciar a aplicação com a flag --proxy-server= definida. Você vai querer usar a interface localhost e a porta que você encaminhou.
Como a conexão é em segundo plano, você terá que encontrar o PID para encerrá-la. Você pode fazer isso procurando pela porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -D 7777 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Você pode então encerrar o processo direcionando o PID, que é o número na segunda coluna, da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a flag -f. Isso manterá a conexão em primeiro plano, impedindo que você use a janela do terminal durante o encaminhamento. O benefício disso é que você pode encerrar facilmente o túnel digitando CTRL-C.
Usando Códigos de Escape SSH para Controlar Conexões
Mesmo após estabelecer uma sessão SSH, é possível exercer controle sobre a conexão de dentro do terminal. Podemos fazer isso com algo chamado códigos de escape SSH, que nos permitem interagir com nosso software SSH local de dentro de uma sessão.
Forçando uma Desconexão do Lado do Cliente (Como Sair de uma Sessão Travada ou Congelada)
Uma das características mais úteis do OpenSSH que passa despercebida em grande parte é a capacidade de controlar certos aspectos da sessão de dentro dela.
Esses comandos podem ser executados começando com o caractere de controle ~ dentro de uma sessão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usar um.
Um dos controles mais úteis é a capacidade de iniciar uma desconexão do cliente. As conexões SSH geralmente são fechadas pelo servidor, mas isso pode ser um problema se o servidor estiver enfrentando problemas ou se a conexão estiver interrompida. Ao usar uma desconexão do lado do cliente, a conexão pode ser fechada de forma limpa do cliente.
Para fechar uma conexão do cliente, use o caractere de controle (~), com um ponto. Se sua conexão estiver com problemas, provavelmente você estará em uma sessão de terminal travada. Digite os comandos apesar da falta de feedback para realizar uma desconexão do lado do cliente:
A conexão deve ser fechada imediatamente, retornando você à sua sessão de shell local.
Colocando uma Sessão SSH em Segundo Plano
Uma das características mais úteis do OpenSSH, que passa largamente despercebida, é a capacidade de controlar certos aspectos da sessão de dentro da conexão.
Esses comandos podem ser executados começando com o caractere de controle ~ de dentro de uma conexão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usar um.
Uma capacidade que isso proporciona é colocar uma sessão SSH em segundo plano. Para fazer isso, precisamos fornecer o caractere de controle (~) e então executar o atalho de teclado convencional para colocar uma tarefa em segundo plano (CTRL-z):
Isso colocará a conexão em segundo plano, retornando você à sua sessão de shell local. Para retornar à sua sessão SSH, você pode usar os mecanismos convencionais de controle de tarefas.
Você pode reativar imediatamente sua tarefa mais recentemente colocada em segundo plano digitando:
Se você tiver várias tarefas em segundo plano, pode ver os trabalhos disponíveis digitando:
Output[1]+ Stopped ssh username@some_host
[2] Stopped ssh username@another_host
Você pode então trazer qualquer uma das tarefas para o primeiro plano usando o índice na primeira coluna com um sinal de porcentagem:
Alterando Opções de Encaminhamento de Porta em uma Conexão SSH Existente
Uma das características mais úteis do OpenSSH que passa despercebida é a capacidade de controlar certos aspectos da sessão de dentro da conexão.
Esses comandos podem ser executados começando com o caractere de controle ~ de dentro de uma conexão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usar um.
Uma coisa que isso permite é que um usuário altere a configuração de encaminhamento de porta após a conexão já ter sido estabelecida. Isso permite que você crie ou desfaça regras de encaminhamento de porta sob demanda.
Essas capacidades fazem parte da interface de linha de comando SSH, que pode ser acessada durante uma sessão usando o caractere de controle (~) e “C”:
ssh>
Você receberá um prompt de comando SSH, que tem um conjunto muito limitado de comandos válidos. Para ver as opções disponíveis, você pode digitar -h deste prompt. Se nada for retornado, você pode ter que aumentar a verbosity da saída do seu SSH usando ~v algumas vezes:
Commands:
-L[bind_address:]port:host:hostport Request local forward
-R[bind_address:]port:host:hostport Request remote forward
-D[bind_address:]port Request dynamic forward
-KL[bind_address:]port Cancel local forward
-KR[bind_address:]port Cancel remote forward
-KD[bind_address:]port Cancel dynamic forward
Como você pode ver, você pode facilmente implementar qualquer uma das opções de encaminhamento usando as opções apropriadas (consulte a seção de encaminhamento para obter mais informações). Você também pode encerrar um túnel com o comando associado “kill” especificado com um “K” antes da letra do tipo de encaminhamento. Por exemplo, para encerrar um encaminhamento local (-L), você pode usar o comando -KL. Você só precisará fornecer a porta para isso.
Portanto, para configurar um encaminhamento de porta local, você pode digitar:
A porta 8888 no seu computador local agora poderá se comunicar com o servidor web no host ao qual você está conectado. Quando terminar, você pode desativar esse encaminhamento digitando:
Conclusão
As instruções acima devem cobrir a maioria das informações que a maioria dos usuários precisará sobre SSH em seu dia a dia. Se você tiver outras dicas ou quiser compartilhar suas configurações e métodos favoritos, sinta-se à vontade para usar os comentários abaixo.