How do you manage users and groups on Linux systems using commands such as useradd, usermod, and groupadd?

There are security implications to putting passwords on the commandline as an argument - they will show up in your shell history. This should be mentioned, or specifying passwords via argument should be omitted.

This is how the creation of users was been done twenty years ago. Reliably tools like Ansible, Chef, Puppet, etcetera, must be the right way to deal with user creation or modification. This way of thinking aligns with the new Zero trust models and adds security layers to any project.

What was explained above I consider is correct but I have some comments about it : 1) Could be nice to include the -c option at creating new users in order to create comments about this created user , for example it can contains "User full name" 2) If you already knows who groups this user be part of, leverage the option -G to define the group. 3) I don't agree with including the -p password option, due to it might be visible because is stored in the shell history , so if someone list the history file, password will be exposed. - An example of how to use this command could be the following: [user@host]~ useradd -md /home/user_name -s /bin/bash user_name

This command is debian base linux. And Redhat base is: [root@Hesari ~]# useradd Mehdi [root@Hesari ~]# passwd Mehdi You can see the user’s home directory.

- I agree with what was explained in the content above. But is important to mention that exists another options available and useful for usermod command - Can be used -d to set new user home directory BUT remember use together the -m option I. order to MOVE the current directories files to the new location. - G option also can be used here with usermod, it will allows you modify the groups this user belongs, BUT be aware of include -a together, if not do that , the user will lost the prior groups and will only maintain the new specified groups. If you use -a it will only append the new group to the user. An example of how to use it: [user@host]~ usermod -aG ProjectManagers user_name

From a security perspective, is important to know that "groupadd" doesn't perform a prior validation if user exists, it also accepts typography errors, this can lead in a future problems. So , for this group adding purpose is better use "usermod" or "gpasswd". They perform validation, logging the operation and work with error handling in order to know if the operation was done with success. Below some examples using both commands: [user@host]~ gpasswd -a Jhon ProjectManagers [user@host]~ usermod -aG ProjectManagers Jhon

I find this information useful. One thing to take into consideration is perform a closing of files under property of this user first. # pkill -15 -u <target_username> # userdel -r <target_username>

I find this information correct, as an additional info about groups also we can get information by doing: #getent group | grep group_name

In my experience The `groupadd` command in Linux can help in creation a new user group on the system which allows you to specify the name of the group and, optionally, the group ID (GID). The basic syntax of the `groupadd` command is as follows: ``` groupadd [options] group_name ``` ``` groupadd developers ``` By default, the `groupadd` command assigns the next available GID to the newly created group. If you want to specify a specific GID for the group, you can use the `-g` option followed by the desired GID number. ``` sudo groupadd developers ```

Fundamentally, unless you have a single server, user creation should not be done individually in most cases. Identity and authentication should be handled by some kind of directory service outside of the host itself. This provides the ability to audit global logins, enforce password policies globally and disable accounts when needed. If accounts are created for services, in most cases they shouldn't even be assigned passwords. Even then, creating those records on the directory server provides assurance that uids and gids are consistent among systems.

You should also consider covering the basics of the Linux Operating System i.e., why do we have groups, what if a user is not part of a group which has access to execute XYZ file on the instance? If we cover these aspects, it will be easier for learners to understand why we have commands like usermod, etc. For example, if we have Docker running on the instance and the current user wants to execute a docker command, they will not be able to run the docker commands unless they are added to the docker group using the 'usermod' command.

(EDIT: Added) Since this article is written from the point of view of a linux sys admin it should mention management tools like Ansible for managing users across multiple systems. Even a "Automation tools like Ansible can reduce the likelihood of errors, like ensuring that UID and GID match across systems" This article should also cover the importance of the user ID and group ID, since permissions are generally based on those. If managing multiple systems, ensuring consistent UID and GIDs can prevent issues (See NFS, where access is based on ID).

In addition, could be helpful to talk about the necessity to create strong passwords, recommend the implementation of two-authentication factor and give a little description of RBAC and how it can be used in Linux to enforce security by managing users based on roles.