Ativando o SSH em hosts d Satellite

Habilite o acesso SSH aos hosts do Satellite para fins de solução de problemas antes ou depois da atribuição do host a um plano de controle ou a um cluster.

Por exemplo, se estiver tendo problemas para atribuir hosts, você pode habilitar um usuário não raiz para acesso SSH a um host antes de atribuí-lo a um cluster.

Consulte as seções a seguir para ver as etapas de ativação do acesso SSH aos hosts.

Ativação do SSH não raiz nos hosts RHCOS antes da atribuição.
Habilitação de SSH não raiz em hosts RHEL antes da atribuição.
Ativação do SSH raiz nos hosts após a atribuição.

Habilitação de SSH não raiz em hosts RHCOS antes da atribuição

RHCOS

Como o acesso SSH raiz normalmente é desativado nos hosts CoreOS e tanto o acesso SSH root quanto o core são desativados como parte da atribuição de host, você pode conceder acesso SSH adicionando um novo usuário não raiz que não seja o usuário padrão core.

Estas instruções descrevem como habilitar o acesso SSH para um novo usuário em um host Red Hat CoreOS antes de atribuí-lo a um cluster ou ao plano de controle.

Reverta essas etapas e desative o acesso SSH após concluir a solução de problemas.

Crie um novo usuário satellite no arquivo de ignição do anexo do host que você usou ao criar o host CoreOS. Edite a seção passwd do arquivo de ignição da seguinte forma.

    "passwd": {
        "users": [
            {
                "name": "core",
                "sshAuthorizedKeys": [
                    ""
                ]
            },
            {
                "name": "satellite",
                "sshAuthorizedKeys": [
                    "ssh-rsa AAA... KEYNAME"
                ],
                "groups": [
                    "sudo"
                ]
            }
        ]
    },

Adicione uma chave pública SSH. Para criar um par de chaves SSH, você pode executar o comando ssh-keygen.
```
ssh-keygen -f ~/.ssh/sat-host-access -t rsa -b 4096 -C sat-host-access -P ''
```
O arquivo sat-host-access.pub tem a chave para adicionar ao arquivo de ignição. Adicione todo o conteúdo do arquivo ao script de ignição, substituindo ssh-rsa AAA... KEYNAME no exemplo acima. A chave privada sat-host-access é o que você usa para fazer o SSH no host.

Qualquer pessoa com a chave privada que corresponde à chave pública que você acabou de adicionar a esse host e com acesso à rede dos nós pode fazer SSH nesse sistema.

Opcional: Execute os seguintes comandos journalctl para coletar registros para depuração.

journalctl -u ibm-host-attach --no-pager

journalctl -u ibm-host-agent --no-pager

journalctl -u ibm-firstboot-ignition --no-pager

Habilitação de SSH não raiz em hosts RHEL antes da atribuição

RHEL

Estas instruções descrevem como habilitar temporariamente o acesso SSH não raiz a um nó de trabalho do cluster RHEL.

Reverta essas etapas e desative o acesso SSH após concluir a solução de problemas.

Antes de começar, verifique se você tem acesso SSH raiz ao host não atribuído.

Se quiser usar a mesma chave SSH para esse novo usuário como o usuário raiz nesse host, não precisará de outra chave. No entanto, se quiser usar um par de chaves SSH diferente para esse novo usuário, tenha esse par de chaves pronto ou crie um novo par de chaves públicas/privadas SSH no sistema que você usa para fazer o SSH no host. Não forneça a chave privada a ninguém. Estas instruções pressupõem que você criou esse novo par de chaves.
```
ssh-keygen -f ~/.ssh/sat-host-access -t rsa -b 4096 -C sat-host-access -P ''`
```

Execute as etapas restantes no próprio host, portanto, faça o SSH no host com autoridade de root antes de continuar.

Crie um usuário e configure-o para ter acesso total ao sudo sem uma senha.

useradd -U -m -s /bin/bash satellite && mkdir -p /home/satellite/.ssh && chown -R satellite:satellite /home/satellite/

Adicione sua chave SSH ao novo usuário.

Se quiser usar a(s) mesma(s) chave(s) SSH para esse usuário e para o usuário root, execute o seguinte comando.

    cp -r /root/.ssh/authorized_keys /home/satellite/.ssh/
    ```
* Se você criou um novo par de chaves ou tem uma chave SSH pública existente, adicione-a ao usuário `satellite` executando o seguinte comando.
```sh {: pre}
    echo "<CONTENTS OF ~/.ssh/sat-host-access.pub OR YOUR OWN PUBLIC KEY>" >> /home/satellite/.ssh/authorized_keys && chmod 600 /home/satellite/.ssh/authorized_keys
    ```

Execute o seguinte comando.

chown -R satellite:satellite /home/satellite/.ssh/authorized_keys

Para conceder a esse novo usuário satellite acesso total ao sudo sem uma senha, execute o seguinte comando.
```
echo "satellite ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
```
Também é possível configurar o usuário para ter uma autoridade mais limitada; em vez disso, configure isso no host. Recomendamos que, para fins de solução de problemas, você conceda a esse usuário acesso total ao sudo. Quando terminar de solucionar o problema, você poderá remover o usuário ou limitar sua autoridade.

Agora, qualquer pessoa com a chave privada que corresponda à chave pública que você acabou de adicionar a esse host e com acesso à rede dos nós pode fazer SSH nesse sistema com autoridade de raiz.
Faça login no nó como o novo usuário para verificar se está funcionando.
```
ssh -i ~/.ssh/sat-host-access satellite@NODE-IP
```
Em seguida, execute o seguinte comando para verificar se você pode obter autoridade de root desse usuário.
```
sudo su - root
```
Opcional: Verifique os diversos arquivos de log gerados pelos processos de registro e inicialização do host. Substitua “ <filepath> ” pelos seguintes arquivos, que devem ser verificados nessa ordem. Dependendo do problema, alguns arquivos de log não estão presentes no servidor caso o processo correspondente não tenha sido executado.
1. Os logs nohup.out da tentativa de registro do host.
2. O /var/log/firstboot.log para a primeira tentativa de autoinicialização. Se o registro do host tiver falhado, você não terá esse arquivo.
3. O /tmp/bootstrap/bootstrap_base.log para o processo de autoinicialização de base, se a primeira inicialização não tiver obtido sucesso. Se o registro do host tiver falhado, você não terá esse arquivo.
```
    tail <filepath>
    ```
1. Execute os comandos `journalctl` para reunir os registros para depuração.

```sh {: pre}
    journalctl -u ibm-host-agent --no-pager
    ```
    ```sh {: pre}
    journalctl -u ibm-firstboot --no-pager
    ```
    ```sh {: pre}
    journalctl -u ibm-host-attach --no-pager
    ```
```

Ativação do SSH raiz nos hosts após a atribuição

RHCOS RHEL

Em alguns cenários de resolução de problemas, é necessário acessar por SSH diretamente um host que já esteja designado como nó de trabalho em um cluster — por exemplo, quando os nós de trabalho do cluster perdem a conectividade com o mestre do cluster. Estas instruções descrevem como habilitar temporariamente o acesso SSH como root a um nó de trabalho do cluster Red Hat CoreOS ou RHEL em um cluster Satellite.

Reverta essas etapas e desative o acesso SSH após concluir a solução de problemas.

Antes de começar, certifique-se de que você tenha o seguinte.

Acesso a um sistema que tenha acesso direto aos trabalhadores do cluster, para ser usado como sistema cliente SSH.
Acesso de administrador a esse cluster para que você possa executar oc debug node/NODE-NAME.

Crie um par de chaves públicas/privadas SSH em seu cliente SSH. Não forneça a chave privada a ninguém.
```
ssh-keygen -f ~/.ssh/sat-host-access -t rsa -b 4096 -C sat-host-access -P ''
```
Verifique se a chave pública foi criada.
```
cat ~/.ssh/sat-host-access.pub
```
Em um sistema que tenha acesso ao mestre do cluster e tenha o acesso admin kubeconfig, execute o seguinte comando.
```
oc debug node/NODE-NAME
```

Execute os seguintes comandos no shell em NODE-NAME para ativar o SSH raiz.

chroot /host

echo "<CONTENTS OF ~/.ssh/sat-host-access.pub>" >> /root/.ssh/authorized_keys

chmod 600 /root/.ssh/authorized_keys

Defina uma variável de ambiente para seu SSHD_CONFIG_FILE usando um dos seguintes comandos. A localização do arquivo de configuração varia de acordo com a versão do worker. Se nenhum dos caminhos de exemplo corresponder ao seu host, defina a variável de ambiente SSHD_CONFIG_FILE com o caminho completo do arquivo de configuração sshd antes de continuar.

Exemplo de comando para CoreOS workers.
```
export SSHD_CONFIG_FILE="/etc/ssh/sshd_config.d/40-rhcos-defaults.conf"
```
Exemplo de comando para trabalhadores do RHEL 9.
```
export SSHD_CONFIG_FILE="/etc/ssh/sshd_config"
```

Verifique a configuração PermitRootLogin.

grep ^PermitRootLogin $SSHD_CONFIG_FILE

Configure PermitRootLogin para yes.

sed -i "s/PermitRootLogin no/PermitRootLogin yes/g" $SSHD_CONFIG_FILE

Verifique a configuração.

grep ^PermitRootLogin $SSHD_CONFIG_FILE

Execute os seguintes comandos para reiniciar e sair.
```
systemctl restart sshd
```
```
exit && exit
```

Nesse ponto, o acesso SSH raiz do sistema cliente SSH é ativado usando a chave privada que você criou anteriormente. Observe que qualquer pessoa com essa chave privada e acesso aos nós pode fazer SSH nesse sistema como root. Use o seguinte comando para fazer SSH no nó: ssh -i ~/.ssh/sat-host-access root@NODE-IP.