Gerenciar Usuários e Grupos no Red Hat Enterprise Linux - RHEL

Introdução

Neste laboratório, você adquirirá habilidades essenciais na gestão de usuários e grupos locais em um ambiente Red Hat Enterprise Linux (RHEL). Você começará compreendendo os conceitos fundamentais de usuários e grupos, incluindo como identificar informações de usuários e grupos e a propriedade de arquivos.

Posteriormente, você aprenderá como obter acesso de superusuário, criar e modificar contas de usuários locais, gerenciar contas de grupos locais e configurar políticas de senhas de usuários. Essa experiência prática o equipará com o conhecimento para controlar efetivamente o acesso e as permissões em seu sistema Linux.

Entender os Conceitos de Usuários e Grupos

Nesta etapa, você aprenderá sobre os conceitos fundamentais de usuários e grupos no Red Hat Enterprise Linux (RHEL) e como usar vários comandos para inspecionar informações de usuários e grupos. Compreender esses conceitos é crucial para gerenciar permissões e controle de acesso em um sistema Linux.

Cada arquivo e processo em um sistema Linux está associado a um usuário e a um grupo. Essa associação determina quem pode ler, escrever ou executar arquivos e quem pode gerenciar processos.

Primeiro, vamos explorar como identificar o usuário atual e outros usuários no sistema usando o comando id.

Use o comando id para mostrar informações sobre o usuário atualmente logado. Este comando exibe o ID do usuário (UID), o ID do grupo primário (GID) e todos os grupos aos quais o usuário pertence.
```
id
```
Você deve ver uma saída semelhante a esta, indicando as informações do seu usuário labex:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Para visualizar informações básicas sobre outro usuário, como o usuário root, passe o nome de usuário para o comando id como um argumento.
```
id root
```
A saída mostrará o UID (0), GID (0) e grupos do usuário root:
```
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```

Em seguida, você aprenderá como identificar o proprietário de arquivos e diretórios usando o comando ls.

Use o comando ls -l para visualizar o proprietário de um arquivo. Primeiro, crie um arquivo fictício em seu diretório ~/project.
```
touch ~/project/mytextfile.txt
ls -l ~/project/mytextfile.txt
```
A saída mostrará labex como o usuário e o proprietário do grupo de mytextfile.txt:
```
-rw-r--r-- 1 labex labex 0 Feb  5 11:10 /home/labex/project/mytextfile.txt
```
Use o comando ls -ld para visualizar o proprietário de um diretório, em vez do conteúdo desse diretório. Na saída a seguir, a terceira coluna mostra o nome de usuário e a quarta coluna mostra o nome do grupo.
```
ls -ld ~/project
```
Você verá labex como o proprietário do seu diretório ~/project:
```
drwxr-xr-x 2 labex labex 6 Feb  5 11:10 /home/labex/project
```

Agora, vamos examinar como visualizar informações do processo e o usuário associado a cada processo usando o comando ps.

Use o comando ps -au para visualizar os processos. A opção a mostra todos os processos com um terminal, e a opção u exibe o usuário que está associado a um processo. Na saída a seguir, a primeira coluna mostra o nome de usuário.

ps -au

Você verá vários processos, com labex e root como usuários comuns:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
root        42  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
labex      123  0.0  0.1 224152  5756 pts/0    Ss   00:00   0:00 -bash
labex      150  0.0  0.0 225556  3652 pts/0    R+   00:00   0:00 ps -au

Finalmente, você explorará os arquivos /etc/passwd e /etc/group, que armazenam informações de usuários e grupos, respectivamente. Esses arquivos são críticos para entender como as contas de usuários e grupos são definidas em um sistema Linux.

Cada linha no arquivo /etc/passwd contém informações sobre um usuário. O arquivo é dividido em sete campos separados por dois pontos. Use cat para visualizar seu conteúdo.
```
cat /etc/passwd
```
Localize a entrada para labex e root. Para labex, deve ser semelhante a isto:
```
labex:x:1000:1000:LabEx User:/home/labex:/bin/bash
```
Vamos detalhar cada campo:
- labex: O nome de usuário para este usuário.
- x: A senha criptografada do usuário era historicamente armazenada aqui; agora é um espaço reservado, pois as senhas são armazenadas em /etc/shadow para segurança.
- 1000: O número UID para esta conta de usuário.
- 1000: O número GID para o grupo primário desta conta de usuário.
- LabEx User: Um breve comentário, descrição ou o nome real para este usuário.
- /home/labex: O diretório home do usuário e o diretório de trabalho inicial quando o shell de login é iniciado.
- /bin/bash: O programa de shell padrão para este usuário que é executado no login.
Cada linha no arquivo /etc/group contém informações sobre um grupo. Cada entrada de grupo é dividida em quatro campos separados por dois pontos. Use cat para visualizar seu conteúdo.
```
cat /etc/group
```
Você verá entradas para vários grupos do sistema e grupos privados do usuário. Por exemplo, a entrada do grupo labex pode ser semelhante a esta:
```
labex:x:1000:
```
Vamos detalhar cada campo:
- labex: Nome para este grupo.
- x: Campo de senha de grupo obsoleto; agora é um espaço reservado.
- 1000: O número GID para este grupo.
- (vazio): Uma lista de usuários que são membros deste grupo como um grupo secundário. Se este campo estiver vazio, significa que nenhum usuário adicional é explicitamente listado como membro secundário deste grupo (embora o usuário primário labex seja implicitamente um membro).
Grupos Primários e Grupos Secundários: Cada usuário tem exatamente um grupo primário. Para usuários locais, este grupo é listado por GID no arquivo /etc/passwd. O grupo primário é o proprietário dos arquivos que o usuário cria. Ao criar um usuário regular, um grupo é frequentemente criado com o mesmo nome do usuário, para ser o grupo primário do usuário. O usuário é normalmente o único membro deste Grupo Privado do Usuário. Este design simplifica o gerenciamento de permissões de arquivos.

Os usuários também podem ter grupos secundários. A associação em grupos secundários é armazenada no arquivo /etc/group. Os usuários recebem acesso aos arquivos com base em se algum de seus grupos tem acesso, independentemente de os grupos serem primários ou secundários. Por exemplo, se o usuário labex tiver um grupo primário labex e wheel como um grupo secundário, então esse usuário pode ler arquivos que qualquer um desses dois grupos pode ler.

O comando id pode mostrar todas as associações de grupo para um usuário. Recorde a saída de id para labex:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Aqui, gid=1000(labex) indica que labex é o grupo primário. groups=1000(labex),10(wheel) lista todas as associações de grupo, mostrando labex como o grupo primário e wheel como um grupo secundário.

Obter Acesso de Superusuário

Nesta etapa, você aprenderá como obter acesso de superusuário (privilégios de root) em um sistema RHEL. O acesso de superusuário é essencial para executar tarefas administrativas, como instalar software, gerenciar usuários e configurar as configurações do sistema. Você explorará os comandos su e sudo, que são as principais ferramentas para a elevação de privilégios.

O comando su (substitute user) permite que você mude para outra conta de usuário. Quando usado sem um nome de usuário, ele assume como padrão o usuário root.

Use o comando su - para mudar para o usuário root. A opção hífen (-) garante que você obtenha um shell de login, o que significa que as variáveis de ambiente e o caminho do usuário root serão carregados. Você será solicitado a inserir a senha root, que é redhat.
```
su -
```
Após inserir a senha redhat, seu prompt mudará para [root@host ~]#, indicando que você agora é o usuário root.
```
Password:
[root@host ~]#
```
Para verificar se você é root, você pode executar o comando whoami:
```
whoami
```
A saída deve ser:
```
root
```
Para sair do shell root e retornar ao seu usuário labex, digite exit.
```
exit
```
Seu prompt retornará para [labex@host ~]$.

O comando sudo (superuser do) permite que um usuário com permissão execute um comando como superusuário ou outro usuário, conforme especificado pelo arquivo sudoers. O usuário labex está configurado para ter privilégios sudo sem exigir uma senha, o que é comum em muitos ambientes de nuvem e laboratório.

Use o comando sudo -i para mudar para a conta root. Este comando é geralmente preferido em relação a su - porque fornece uma maneira mais segura de executar comandos com privilégios elevados. Quando você usa sudo -i, você ainda está usando sua própria conta de usuário, mas com privilégios de root, e os comandos são registrados em sua conta, tornando mais fácil rastrear o que foi feito.
```
sudo -i
```
Seu prompt mudará para [root@host ~]#, indicando que você agora é o usuário root.
```
[root@host ~]#
```
Novamente, você pode verificar com whoami:
```
whoami
```
A saída deve ser:
```
root
```
Para sair do shell root e retornar ao seu usuário labex, digite exit.
```
exit
```
Seu prompt retornará para [labex@host ~]$.
Você também pode usar sudo para executar um único comando com privilégios de root sem mudar para o shell root. Por exemplo, para visualizar o conteúdo de /etc/shadow (que só pode ser lido por root), você pode usar sudo cat /etc/shadow.
```
sudo cat /etc/shadow | head -n 3
```
Isso exibirá as três primeiras linhas do arquivo /etc/shadow, demonstrando que o comando cat foi executado com privilégios de root.
```
root:*:19780:0:99999:7:::
bin:*:19780:0:99999:7:::
daemon:*:19780:0:99999:7:::
```
O arquivo /etc/sudoers é o principal arquivo de configuração para o comando sudo. Ele define quais usuários ou grupos podem executar quais comandos com privilégios elevados. Para evitar problemas se vários administradores tentarem editar o arquivo ao mesmo tempo, você deve editá-lo apenas com o comando especial visudo. O editor visudo também valida o arquivo, para garantir que não haja erros de sintaxe.

Uma entrada comum em /etc/sudoers permite que membros do grupo wheel executem qualquer comando como root. O usuário labex é membro do grupo wheel, e é por isso que sudo funciona sem uma senha.
```
sudo grep wheel /etc/sudoers
```
Você deve ver uma linha semelhante a esta, que concede acesso sudo ao grupo wheel:
```
%wheel        ALL=(ALL:ALL)       ALL
```
Esta linha significa:
- %wheel: A regra se aplica aos membros do grupo wheel. O símbolo % denota um grupo.
- ALL=(ALL:ALL): Em qualquer host (primeiro ALL), os usuários do grupo wheel podem executar comandos como qualquer usuário (segundo ALL) e qualquer grupo (terceiro ALL).
- ALL: Os usuários do grupo wheel podem executar qualquer comando.

Isso conclui sua exploração para obter acesso de superusuário. Agora você entende a diferença entre su - e sudo -i e como executar comandos com privilégios elevados.

Criar e Modificar Contas de Usuário Locais

Nesta etapa, você aprenderá como criar, modificar e excluir contas de usuários locais em um sistema RHEL. Gerenciar contas de usuários é uma tarefa administrativa fundamental, garantindo que cada usuário tenha acesso e permissões apropriadas. Você usará comandos como useradd, usermod, userdel e passwd.

Primeiro, vamos criar uma nova conta de usuário.

Use o comando useradd para criar um novo usuário. Por padrão, useradd cria um novo usuário com um UID maior ou igual a 1000, cria um diretório home (/home/nome_de_usuário) e define o shell padrão como /bin/bash. Você precisa de privilégios sudo para executar este comando. Vamos criar um usuário chamado testuser01.
```
sudo useradd testuser01
```
Após criar o usuário, você pode verificar sua existência em /etc/passwd e verificar seu diretório home.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
Você deve ver uma saída semelhante a esta:
```
testuser01:x:1001:1001::/home/testuser01:/bin/bash
drwx------. 2 testuser01 testuser01 6 Mar  4 15:22 /home/testuser01
```
Por padrão, os usuários recém-criados não têm uma senha definida, o que significa que eles não podem fazer login. Você precisa definir uma senha para testuser01 usando o comando passwd.
```
sudo passwd testuser01
```
Você será solicitado a inserir uma nova senha. Para este laboratório, use labexrhel9 como a senha para testuser01. Você pode ver um aviso "BAD PASSWORD", mas pode prosseguir.
```
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
```
Agora, tente mudar para testuser01 usando su -.
```
su - testuser01
```
Insira a senha labexrhel9 quando solicitado. Seu prompt deve mudar para [testuser01@host ~]$.
```
Password:
[testuser01@host ~]$
```
Para retornar ao seu usuário labex, digite exit.
```
exit
```

Em seguida, vamos modificar uma conta de usuário existente usando o comando usermod. O comando usermod permite que você altere várias propriedades de um usuário, como seu diretório home, shell ou associações de grupo.

Vamos alterar o campo de comentário (nome completo) para testuser01 para "Test User One".
```
sudo usermod -c "Test User One" testuser01
```
Verifique a alteração verificando o arquivo /etc/passwd novamente.
```
grep testuser01 /etc/passwd
```
A saída agora deve refletir o comentário atualizado:
```
testuser01:x:1001:1001:Test User One:/home/testuser01:/bin/bash
```
Você também pode bloquear ou desbloquear uma conta de usuário. Bloquear uma conta impede que o usuário faça login, enquanto desbloqueá-la reabilita o login.

Para bloquear a conta testuser01:
```
sudo usermod -L testuser01
```
Agora, tente mudar para testuser01 novamente.
```
su - testuser01
```
Você será solicitado a inserir a senha, mas mesmo com a senha correta, o login falhará:
```
Password:
su: Authentication failure
```
Para desbloquear a conta testuser01:
```
sudo usermod -U testuser01
```
Tente mudar para testuser01 novamente, e deve ter sucesso. Lembre-se de exit para retornar a labex.
```
su - testuser01
## Enter password 'labexrhel9'
exit
```

Finalmente, vamos excluir a conta de usuário que você criou.

Use o comando userdel para remover um usuário. Por padrão, userdel remove a entrada do usuário de /etc/passwd, mas deixa seu diretório home intacto. Isso pode levar a arquivos órfãos.
```
sudo userdel testuser01
```
Verifique se o usuário é removido de /etc/passwd, mas o diretório home ainda existe.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
O comando grep não deve retornar nenhuma saída, indicando que o usuário se foi. O comando ls -ld mostrará que o diretório home ainda existe, mas sua propriedade aparecerá como UIDs/GIDs numéricos, pois o usuário não existe mais.
```
drwx------ 2 1001 1001 83 Mar  4 15:22 /home/testuser01
```
Observação: Em algumas versões ou configurações do RHEL, userdel pode remover o diretório home por padrão se estiver vazio ou se o usuário for o único proprietário. No entanto, é mais seguro usar explicitamente a opção -r para garantir que o diretório home seja removido.
Para remover o usuário e seu diretório home, use a opção -r com userdel. Vamos criar um novo usuário testuser02 para demonstrar isso corretamente.
```
sudo useradd testuser02
sudo passwd testuser02 ## You'll be prompted to enter 'labexrhel9'
```
Agora, remova testuser02 e seu diretório home:
```
sudo userdel -r testuser02
```
Verifique se a entrada do usuário e o diretório home foram removidos.
```
grep testuser02 /etc/passwd
ls -ld /home/testuser02
```
Ambos os comandos devem indicar que testuser02 e seu diretório home não existem mais.
```
ls: cannot access '/home/testuser02': No such file or directory
```

Isso conclui sua prática com a criação, modificação e exclusão de contas de usuários locais.

Gerenciar Contas de Grupo Locais

Nesta etapa, você aprenderá como gerenciar contas de grupos locais em um sistema RHEL. Os grupos são fundamentais para gerenciar permissões de forma eficiente, permitindo que você conceda acesso a vários usuários simultaneamente. Você usará comandos como groupadd, groupmod e groupdel, e também revisitará usermod para gerenciar associações de usuário-grupo.

Primeiro, vamos criar um novo grupo.

Use o comando groupadd para criar um novo grupo. Por padrão, groupadd atribui o próximo GID disponível da faixa especificada em /etc/login.defs. Você precisa de privilégios sudo para executar este comando. Vamos criar um grupo chamado developers.
```
sudo groupadd developers
```
Você pode verificar a criação do grupo verificando o arquivo /etc/group.
```
grep developers /etc/group
```
Você deve ver uma entrada semelhante a esta:
```
developers:x:1002:
```
Você também pode especificar um GID específico para o grupo usando a opção -g. Vamos criar outro grupo chamado testers com um GID específico, por exemplo, 2000.
```
sudo groupadd -g 2000 testers
```
Verifique o GID do grupo testers.
```
grep testers /etc/group
```
A saída deve confirmar o GID especificado:
```
testers:x:2000:
```

Em seguida, vamos modificar um grupo existente usando o comando groupmod.

Você pode alterar o nome de um grupo usando a opção -n. Vamos renomear testers para qa_team.
```
sudo groupmod -n qa_team testers
```
Verifique a alteração do nome em /etc/group.
```
grep qa_team /etc/group
```
A saída deve mostrar o novo nome com o GID original:
```
qa_team:x:2000:
```
Você também pode alterar o GID de um grupo usando a opção -g. Vamos alterar o GID de qa_team para 2001.
```
sudo groupmod -g 2001 qa_team
```
Verifique a alteração do GID.
```
grep qa_team /etc/group
```
A saída deve refletir o novo GID:
```
qa_team:x:2001:
```

Agora, vamos gerenciar as associações de usuários dentro desses grupos. Você usará o comando usermod para isso. Primeiro, crie alguns usuários de teste.

Crie userA e userB e defina suas senhas como labexrhel9.
```
sudo useradd userA
sudo passwd userA
```
Digite labexrhel9 como a senha para userA.
```
sudo useradd userB
sudo passwd userB
```
Digite labexrhel9 como a senha para userB.
Adicione userA ao grupo developers como um grupo secundário. Use as opções -a (append) e -G (groups) com usermod.
```
sudo usermod -aG developers userA
```
Verifique as associações de grupo de userA usando o comando id.
```
id userA
```
Você deve ver developers listado na seção groups:
```
uid=1003(userA) gid=1003(userA) groups=1003(userA),1002(developers)
```
Adicione userB aos grupos developers e qa_team como grupos secundários.
```
sudo usermod -aG developers,qa_team userB
```
Verifique as associações de grupo de userB.
```
id userB
```
Você deve ver developers e qa_team listados:
```
uid=1004(userB) gid=1004(userB) groups=1004(userB),1002(developers),2001(qa_team)
```
Você também pode alterar o grupo primário de um usuário usando a opção -g com usermod. Vamos alterar o grupo primário de userA para developers.
```
sudo usermod -g developers userA
```
Verifique o grupo primário de userA.
```
id userA
```
O campo gid agora deve mostrar developers:
```
uid=1003(userA) gid=1002(developers) groups=1002(developers)
```
Observação: Quando você altera o grupo primário de um usuário, ele é removido da lista de associação de seu grupo primário antigo em /etc/group se esse grupo também fosse um grupo secundário. Neste caso, o grupo primário original de userA (userA) não está mais listado como um grupo secundário.

Finalmente, vamos excluir os grupos e usuários de teste que você criou.

Use o comando groupdel para remover um grupo. Você não pode excluir um grupo se ele for o grupo primário de qualquer usuário. Primeiro, altere o grupo primário de userA de volta para seu padrão (ou outro grupo existente) antes de excluir developers.
```
sudo usermod -g userA userA ## Change userA's primary group back to userA
sudo groupdel developers
```
Verifique se developers é removido de /etc/group.
```
grep developers /etc/group
```
Este comando não deve retornar nenhuma saída.
Exclua o grupo qa_team.
```
sudo groupdel qa_team
```
Verifique sua remoção.
```
grep qa_team /etc/group
```
Este comando também não deve retornar nenhuma saída.

Limpe os usuários de teste.

sudo userdel -r userA
sudo userdel -r userB

Isso conclui sua prática com o gerenciamento de contas de grupos locais e associações de usuário-grupo.

Configurar Políticas de Senha de Usuário

Nesta etapa, você aprenderá como configurar políticas de senha de usuário em um sistema RHEL. As políticas de senha são cruciais para aprimorar a segurança, impondo regras sobre a complexidade da senha, expiração e bloqueio da conta. Você explorará o arquivo /etc/shadow e o comando chage.

Primeiro, vamos entender o arquivo /etc/shadow, que armazena informações de senha criptografadas e parâmetros de envelhecimento de senha para contas de usuário. Este arquivo é altamente sensível e só pode ser lido pelo usuário root.

Cada usuário tem uma entrada no arquivo /etc/shadow. Vamos criar um novo usuário policyuser e definir sua senha como labexrhel9 para fins de demonstração.
```
sudo useradd policyuser
sudo passwd policyuser
```
Digite labexrhel9 como a senha para policyuser.
Agora, visualize a entrada para policyuser em /etc/shadow.
```
sudo grep policyuser /etc/shadow
```
Você verá uma saída semelhante a esta:
```
policyuser:$6$randomsalt$encryptedhash:19780:0:99999:7:::
```
Vamos detalhar cada campo, separado por dois pontos:
- policyuser: Nome da conta de usuário.
- $6$randomsalt$encryptedhash: A senha criptografada do usuário.
  - $6: O algoritmo de hashing em uso para esta senha (SHA-512, o padrão do RHEL 9).
  - randomsalt: O sal usado para criptografar a senha; originalmente escolhido aleatoriamente.
  - encryptedhash: O hash criptografado da senha do usuário.
- 19780: Os dias desde a época (1970-01-01 UTC) em que a senha foi alterada pela última vez. Este número variará com base na data atual.
- 0: O número mínimo de dias desde a última alteração da senha antes que o usuário possa alterá-la novamente.
- 99999: O número máximo de dias sem alteração de senha antes que a senha expire. Um campo vazio significa que a senha nunca expira.
- 7: O número de dias de antecedência para avisar o usuário que sua senha expirará.
- (vazio): O número de dias sem atividade, começando com o dia em que a senha expirou, antes que a conta seja bloqueada automaticamente.
- (vazio): O dia em que a conta expira em dias desde a época. Um campo vazio significa que a conta nunca expira.
- O último campo é normalmente vazio e reservado para uso futuro.

Em seguida, você usará o comando chage para modificar esses parâmetros de envelhecimento de senha. O comando chage permite que você altere as informações de expiração da senha do usuário.

Vamos definir uma política de senha para policyuser com as seguintes regras:
- Número mínimo de dias entre as alterações de senha: 7 dias (-m 7)
- Número máximo de dias entre as alterações de senha: 90 dias (-M 90)
- Período de aviso antes da expiração da senha: 14 dias (-W 14)
- Período de inatividade após a expiração da senha antes do bloqueio da conta: 30 dias (-I 30)
```
sudo chage -m 7 -M 90 -W 14 -I 30 policyuser
```

Para verificar essas alterações, você pode usar chage -l (list) para exibir as informações atuais de envelhecimento da senha para policyuser.

sudo chage -l policyuser

Você deve ver a saída refletindo a nova política:

Last password change     : Mar 04, 2024
Password expires     : Jun 02, 2024
Password inactive     : Jul 02, 2024
Account expires      : never
Minimum number of days between password change  : 7
Maximum number of days between password change  : 90
Number of days of warning before password expires : 14

Observação: As datas variarão com base em quando você realizar o laboratório.

Você também pode definir uma data de expiração absoluta da conta usando a opção -E. Vamos definir a conta de policyuser para expirar em 30 dias a partir de hoje. Primeiro, obtenha a data de hoje e calcule a data 30 dias a partir de agora.
```
EXPIRY_DATE=$(date -d "+30 days" +%Y-%m-%d)
echo "Account will expire on: $EXPIRY_DATE"
sudo chage -E $EXPIRY_DATE policyuser
```
Verifique a data de expiração da conta.
```
sudo chage -l policyuser | grep "Account expires"
```
A saída deve mostrar a data de expiração calculada:
```
Account expires      : Apr 03, 2024
```
Observação: A data será aproximadamente 30 dias a partir da data atual do seu laboratório.
Para remover a data de expiração da conta, você pode usar chage -E -1 policyuser.
```
sudo chage -E -1 policyuser
sudo chage -l policyuser | grep "Account expires"
```
A saída deve retornar para never:
```
Account expires      : never
```

Finalmente, limpe a conta policyuser.

sudo userdel -r policyuser

Isso conclui sua prática com a configuração de políticas de senha de usuário. Agora você entende como inspecionar e modificar os parâmetros de envelhecimento da senha usando o arquivo /etc/shadow e o comando chage.

Resumo

Neste laboratório, você aprendeu conceitos fundamentais de gerenciamento de usuários e grupos no Red Hat Enterprise Linux (RHEL). Você começou entendendo como usuários e grupos são associados a arquivos e processos, e como inspecionar informações de usuários e grupos usando o comando id tanto para o usuário atual quanto para outros usuários do sistema, como root. Você também praticou a identificação da propriedade de arquivos e diretórios usando os comandos ls -l e ls -ld, respectivamente, o que é crucial para entender permissões e controle de acesso.

O laboratório guiou você ainda mais através da obtenção de acesso de superusuário, criação e modificação de contas de usuário locais, gerenciamento de contas de grupos locais e configuração de políticas de senha de usuário. Essas etapas forneceram experiência prática em tarefas essenciais de administração do sistema, permitindo que você gerenciasse efetivamente o acesso do usuário e a segurança em um sistema Linux.