本文档风哥主要介绍Linux用户组管理相关知识，包括groupadd命令创建用户组、groupmod命令修改用户组、groupdel命令删除用户组、用户组配置文件管理、批量用户组管理等内容，参考Red Hat Enterprise Linux 10官方文档，适合运维人员在学习和测试中使用，如果要应用于生产环境则需要自行确认。更多视频教程www.fgedu.net.cn
Part01-基础概念与理论知识
1.1 Linux用户组管理概念
Linux用户组（Group）是用户的管理单元，用于实现用户的分类管理和权限控制。每个用户都属于一个主组（Primary Group）和若干个附加组（Supplementary Group）。用户组通过GID（Group ID）来标识，系统通过GID来识别用户组。
- 权限管理：通过组权限控制文件访问
- 资源共享：组成员可以共享文件和资源
- 简化管理：批量管理用户权限
- 安全隔离：不同组之间权限隔离
1.2 Linux用户组类型
Linux用户组分为两种类型：
- 系统组：GID为0-999，用于系统服务和管理
- 普通组：GID从1000开始，用于用户管理
# cat /etc/group | awk -F: ‘{print $3}’ | sort -n | head -n 10
0
1
2
3
4
5
6
7
8
10
# 查看普通组
# cat /etc/group | awk -F: ‘$3 >= 1000 {print $1, $3}’
fgedu 1000
developers 1001
ops 1002
dba 1003
# 查看root组信息
# cat /etc/group | grep “^root”
root:x:0:
# 查看用户所属组
# groups fgedu
fgedu : fgedu wheel docker
# 查看用户主组
# id -gn fgedu
fgedu
# 查看用户附加组
# id -Gn fgedu
fgedu wheel docker
# 查看组内所有用户
# groupmems -g wheel -l
fgedu dev001 dev002
1.3 Linux用户组相关文件
Linux用户组管理涉及的主要配置文件：
- /etc/group：用户组信息文件
- /etc/gshadow：用户组密码信息文件
- /etc/login.defs：用户组创建默认配置
# head -n 5 /etc/group
root:x:0:
bin:x:1:
daemon:x:2:
sys:x:3:
adm:x:4:
# 字段说明：
# 组名:密码占位符:GID:组成员列表
# 查看/etc/gshadow文件格式
# head -n 5 /etc/gshadow
root:::
bin:::
daemon:::
sys:::
adm:::
# 字段说明：
# 组名:加密密码:组管理员:组成员
# 查看组密码
# grep “^wheel:” /etc/gshadow
wheel:::fgedu,dev001,dev002
# 查看系统默认GID范围
# grep -E “^GID_MIN|^GID_MAX” /etc/login.defs
GID_MIN 1000
GID_MAX 60000
# 查看组内成员数量
# groupmems -g wheel -l | wc -w
3
Part02-生产环境规划与建议
2.1 用户组命名规范
在生产环境中，用户组命名应遵循统一的规范：
# 1. 命名规则
– 长度：1-32个字符
– 字符：小写字母、数字、下划线、连字符
– 格式：部门-功能 或 功能-级别
– 示例：developers, ops-team, dba-admins
# 2. 常见用户组分类
# 按部门分类
developers # 开发部门
ops # 运维部门
dba # 数据库部门
security # 安全部门
# 按功能分类
docker # Docker用户组
wheel # sudo用户组
apache # Apache用户组
mysql # MySQL用户组
# 按项目分类
projectA-dev # 项目A开发组
projectA-ops # 项目A运维组
projectB-dev # 项目B开发组
# 按权限级别分类
admin # 管理员组
readonly # 只读组
readwrite # 读写组
# 3. 用户组命名示例
# 应用组
app-mysql
app-nginx
app-redis
app-tomcat
# 环境组
env-dev
env-test
env-prod
# 服务组
svc-web
svc-db
svc-cache
2.2 用户组管理策略
生产环境用户组管理策略：
# 1. 用户组规划原则
– 按部门划分主组
– 按功能划分附加组
– 按项目划分临时组
– 按权限级别划分权限组
# 2. 用户组权限规划
# 目录权限示例
/production/ # 生产环境目录
├── app/ # 应用目录（app组）
├── db/ # 数据库目录（dba组）
└── logs/ # 日志目录（ops组）
# 设置目录组权限
# chown -R root:developers /production/app
# chmod -R 775 /production/app
# chown -R root:dba /production/db
# chmod -R 770 /production/db
# chown -R root:ops /production/logs
# chmod -R 775 /production/logs
# 3. 用户组成员管理
# 主组：用户的主要归属，创建文件时默认组
# 附加组：用户的额外权限组
# 示例：开发人员组规划
# 主组：developers
# 附加组：wheel, docker, git
# 创建开发人员
# useradd -g developers -G wheel,docker,git dev001
# 4. 用户组密码策略
# 设置组密码（用于newgrp命令）
# gpasswd developers
# 添加组管理员
# gpasswd -A dev001 developers
# 添加组成员
# gpasswd -a dev002 developers
# 5. 用户组审计策略
# 定期检查组内成员
# groupmems -g wheel -l
# 检查空组
# awk -F: ‘$4 == “” {print $1}’ /etc/group
# 检查重复GID
# awk -F: ‘{print $3}’ /etc/group | sort | uniq -d
2.3 用户组安全建议
生产环境用户组安全建议：
- 定期审计用户组成员
- 及时清理无用用户组
- 合理设置组权限
- 避免过多用户加入特权组
- 使用组密码保护特权组
- 记录用户组变更日志
# 1. 检查特权组成员
# groupmems -g wheel -l
fgedu dev001 dev002
# 检查sudo组成员
# grep “^%wheel” /etc/sudoers
%wheel ALL=(ALL) ALL
# 2. 设置组密码保护
# gpasswd wheel
Changing the password for group wheel
New Password:
Re-enter new password:
# 3. 设置组管理员
# gpasswd -A fgedu wheel
# grep “^wheel:” /etc/gshadow
wheel:$6$xxx:fgedu:fgedu,dev001,dev002
# 4. 限制组成员数量
# 检查组成员数量
# for group in wheel docker root; do
count=$(groupmems -g $group -l 2>/dev/null | wc -w)
echo “$group: $count members”
done
wheel: 3 members
docker: 5 members
root: 0 members
# 5. 检查组权限文件
# ls -l /etc/group /etc/gshadow
-rw-r–r–. 1 root root 1234 Apr 2 10:00 /etc/group
-r——–. 1 root root 1234 Apr 2 10:00 /etc/gshadow
# 修复权限
# chmod 644 /etc/group
# chmod 400 /etc/gshadow
# 6. 检查空密码组
# awk -F: ‘$2 == “” {print $1}’ /etc/gshadow | head -n 10
root
bin
daemon
sys
adm
tty
disk
lp
mem
kmem
# 7. 检查无主组
# awk -F: ‘$3 >= 1000 {print $1}’ /etc/group | while read group; do
members=$(groupmems -g $group -l 2>/dev/null)
if [ -z “$members” ]; then
echo “Empty group: $group”
fi
done
Empty group: testgroup
Empty group: oldgroup
# 8. 删除空组
# groupdel testgroup
# groupdel oldgroup
Part03-生产环境项目实施方案
3.1 groupadd命令创建用户组
groupadd命令用于创建新用户组。
# 1. 创建基本用户组
# groupadd developers
# grep “developers” /etc/group
developers:x:1001:
# 2. 创建用户组并指定GID
# groupadd -g 2000 ops
# grep “ops” /etc/group
ops:x:2000:
# 3. 创建系统组
# groupadd -r systemapp
# grep “systemapp” /etc/group
systemapp:x:994:
# 4. 创建用户组并设置密码
# groupadd dba
# gpasswd dba
Changing the password for group dba
New Password:
Re-enter new password:
# 5. 创建用户组并指定GID范围
# groupadd -K GID_MIN=5000 -K GID_MAX=6000 highgidgroup
# grep “highgidgroup” /etc/group
highgidgroup:x:5000:
# 6. 创建用户组并添加成员
# groupadd projectA
# gpasswd -a dev001 projectA
Adding user dev001 to group projectA
# gpasswd -a dev002 projectA
Adding user dev002 to group projectA
# 7. 查看组内成员
# groupmems -g projectA -l
dev001 dev002
# 8. 创建用户组并设置组管理员
# groupadd projectB
# gpasswd -A dev001 projectB
# grep “^projectB:” /etc/gshadow
projectB:!::dev001
# 9. 创建用户组并指定重复GID（强制）
# groupadd -o -g 1000 testgroup
# grep “testgroup” /etc/group
testgroup:x:1000:
# 10. 创建用户组并指定密码（非交互式）
# groupadd securegroup
# echo “GroupPass123” | gpasswd securegroup
# 11. 批量创建用户组
# for group in dev test prod; do
groupadd $group
done
# 验证创建结果
# grep -E “^(dev|test|prod):” /etc/group
dev:x:1002:
test:x:1003:
prod:x:1004:
# 12. 创建用户组并设置权限目录
# groupadd appdata
# mkdir -p /data/app
# chown root:appdata /data/app
# chmod 775 /data/app
# ls -ld /data/app
drwxrwxr-x. 2 root appdata 6 Apr 2 10:00 /data/app
# 13. 创建用户组并添加多个成员
# groupadd teamA
# gpasswd -M dev001,dev002,dev003 teamA
# groupmems -g teamA -l
dev001 dev002 dev003
# 14. 创建用户组并设置SGID目录
# groupadd shared
# mkdir /shared
# chown root:shared /shared
# chmod 2775 /shared
# ls -ld /shared
drwxrwsr-x. 2 root shared 6 Apr 2 10:00 /shared
# 15. 创建用户组并验证GID唯一性
# groupadd -g 3000 uniquegroup
# awk -F: ‘$3 == 3000 {print $1}’ /etc/group
uniquegroup
3.2 groupmod命令修改用户组
groupmod命令用于修改已有用户组的属性。
# 1. 修改用户组名称
# groupmod -n newdevelopers developers
# grep “newdevelopers” /etc/group
newdevelopers:x:1001:
# 2. 修改用户组GID
# groupmod -g 3000 ops
# grep “ops” /etc/group
ops:x:3000:
# 3. 修改用户组名称和GID
# groupmod -n newops -g 4000 ops
# grep “newops” /etc/group
newops:x:4000:
# 4. 修改用户组为系统组
# groupmod -o -g 500 newops
# grep “newops” /etc/group
newops:x:500:
# 5. 修改用户组密码
# gpasswd newdevelopers
Changing the password for group newdevelopers
New Password:
Re-enter new password:
# 6. 添加组成员
# gpasswd -a dev001 newdevelopers
Adding user dev001 to group newdevelopers
# 7. 删除组成员
# gpasswd -d dev001 newdevelopers
Removing user dev001 from group newdevelopers
# 8. 设置组管理员
# gpasswd -A dev001 newdevelopers
# grep “^newdevelopers:” /etc/gshadow
newdevelopers:$6$xxx:dev001:
# 9. 删除组管理员
# gpasswd -A “” newdevelopers
# grep “^newdevelopers:” /etc/gshadow
newdevelopers:$6$xxx::
# 10. 批量设置组成员
# gpasswd -M dev001,dev002,dev003 newdevelopers
# groupmems -g newdevelopers -l
dev001 dev002 dev003
# 11. 修改用户主组
# usermod -g newdevelopers dev001
# id dev001
uid=2000(dev001) gid=1001(newdevelopers) groups=1001(newdevelopers),10(wheel)
# 12. 修改用户附加组
# usermod -aG newdevelopers dev002
# id dev002
uid=2001(dev002) gid=1001(newdevelopers) groups=1001(newdevelopers),10(wheel)
# 13. 修改组权限目录
# chown -R root:newdevelopers /data/app
# chmod -R 775 /data/app
# 14. 修改组文件所有权
# find /home -group developers -exec chgrp newdevelopers {} \;
# 15. 验证用户组修改
# cat /etc/group | grep -E “newdevelopers|newops”
newdevelopers:x:1001:dev001,dev002,dev003
newops:x:500:
3.3 groupdel命令删除用户组
groupdel命令用于删除用户组。
# 1. 删除用户组
# groupdel testgroup
# grep “testgroup” /etc/group
（无输出，表示已删除）
# 2. 删除用户组前检查成员
# groupmems -g oldgroup -l
dev001 dev002
# 移除组成员
# gpasswd -d dev001 oldgroup
# gpasswd -d dev002 oldgroup
# 删除用户组
# groupdel oldgroup
# 3. 删除用户组前检查用户主组
# grep “testgroup” /etc/passwd
dev001:x:2000:1001::/home/dev001:/bin/bash
# 修改用户主组
# usermod -g developers dev001
# 删除用户组
# groupdel testgroup
# 4. 强制删除用户组（不推荐）
# groupdel -f testgroup
（可能导致用户主组丢失）
# 5. 删除用户组前备份
# grep “testgroup” /etc/group > /tmp/testgroup.backup
# groupdel testgroup
# 6. 批量删除用户组
# for group in dev test prod; do
groupdel $group
done
# 7. 删除用户组并清理权限
# groupdel oldgroup
# find / -group oldgroup -exec chgrp root {} \; 2>/dev/null
# 8. 删除用户组前检查文件
# find /home -group oldgroup -ls
1234567 4 -rw-r–r– 1 dev001 oldgroup 1234 Apr 2 10:00 /home/dev001/file.txt
# 更改文件组
# find /home -group oldgroup -exec chgrp developers {} \;
# 删除用户组
# groupdel oldgroup
# 9. 删除用户组前检查sudo配置
# grep “oldgroup” /etc/sudoers
%oldgroup ALL=(ALL) ALL
# 删除sudo配置
# visudo
（删除相关行）
# 删除用户组
# groupdel oldgroup
# 10. 删除用户组前检查cron任务
# grep “oldgroup” /etc/cron.allow
oldgroup
# 删除cron配置
# sed -i ‘/oldgroup/d’ /etc/cron.allow
# 删除用户组
# groupdel oldgroup
# 11. 删除用户组并归档数据
# mkdir -p /archive/groups
# tar -czf /archive/groups/oldgroup-$(date +%Y%m%d).tar.gz /data/oldgroup
# groupdel oldgroup
# 12. 检查用户组是否已删除
# grep “testgroup” /etc/group
（无输出，表示已删除）
# 13. 删除空用户组
# for group in $(awk -F: ‘$3 >= 1000 {print $1}’ /etc/group); do
members=$(groupmems -g $group -l 2>/dev/null)
if [ -z “$members” ]; then
echo “Deleting empty group: $group”
groupdel $group
fi
done
# 14. 删除用户组并更新用户配置
# groupdel oldgroup
# sed -i ‘s/oldgroup/developers/g’ /etc/passwd
# 15. 验证用户组删除
# id dev001
uid=2000(dev001) gid=1001(developers) groups=1001(developers),10(wheel)
Part04-生产案例与实战讲解
4.1 批量创建用户组案例
在生产环境中，经常需要批量创建用户组，以下是一个完整的批量创建用户组脚本。
# 1. 创建用户组列表文件
# cat > /tmp/grouplist.txt << EOF
developers,1001,Development Team
ops,1002,Operations Team
dba,1003,DBA Team
security,1004,Security Team
docker,993,Container Team
EOF
# 2. 批量创建用户组脚本
# cat > /tmp/batch_create_groups.sh << 'EOF'
#!/bin/bash
GROUPLIST="/tmp/grouplist.txt"
LOGFILE="/tmp/group_creation.log"
# 创建日志文件
echo "Group Creation Log - $(date)" > $LOGFILE
# 读取用户组列表
while IFS=’,’ read -r groupname gid description; do
# 检查用户组是否存在
if grep “^$groupname:” /etc/group &>/dev/null; then
echo “Group $groupname already exists” | tee -a $LOGFILE
continue
fi
# 检查GID是否已被使用
if awk -F: -v gid=$gid ‘$3 == gid {print}’ /etc/group | grep -q .; then
echo “GID $gid already in use, skipping $groupname” | tee -a $LOGFILE
continue
fi
# 创建用户组
if [ -z “$gid” ]; then
groupadd $groupname
else
groupadd -g $gid $groupname
fi
echo “Group $groupname created successfully with GID $gid” | tee -a $LOGFILE
done < $GROUPLIST
echo "Group creation completed" | tee -a $LOGFILE
EOF
# 3. 执行脚本
# chmod +x /tmp/batch_create_groups.sh
# /tmp/batch_create_groups.sh
Group Creation Log - Fri Apr 2 10:00:00 CST 2026
Group developers created successfully with GID 1001
Group ops created successfully with GID 1002
Group dba created successfully with GID 1003
Group security created successfully with GID 1004
Group docker created successfully with GID 993
Group creation completed
# 4. 验证用户组创建
# tail -n 10 /etc/group
developers:x:1001:
ops:x:1002:
dba:x:1003:
security:x:1004:
docker:x:993:
# 5. 批量添加用户到组
# cat > /tmp/add_users_to_groups.sh << 'EOF'
#!/bin/bash
# 定义用户组与用户映射
declare -A GROUP_USERS=(
["developers"]="dev001,dev002,dev003"
["ops"]="ops001,ops002"
["dba"]="dba001"
["security"]="sec001,sec002"
["docker"]="dev001,dev002,ops001"
)
for group in "${!GROUP_USERS[@]}"; do
users=${GROUP_USERS[$group]}
IFS=',' read -ra USER_ARRAY <<< "$users"
for user in "${USER_ARRAY[@]}"; do
# 检查用户是否存在
if id $user &>/dev/null; then
gpasswd -a $user $group
echo “Added $user to $group”
else
echo “User $user does not exist, skipping”
fi
done
done
EOF
# chmod +x /tmp/add_users_to_groups.sh
# /tmp/add_users_to_groups.sh
Adding user dev001 to group developers
Adding user dev002 to group developers
Adding user dev003 to group developers
Adding user ops001 to group ops
Adding user ops002 to group ops
Adding user dba001 to group dba
Adding user sec001 to group security
Adding user sec002 to group security
Adding user dev001 to group docker
Adding user dev002 to group docker
Adding user ops001 to group docker
# 6. 验证组成员
# groupmems -g developers -l
dev001 dev002 dev003
# groupmems -g docker -l
dev001 dev002 ops001
4.2 用户组权限管理案例
通过用户组实现文件和目录的权限管理。
# 1. 创建项目目录结构
# mkdir -p /project/{dev,test,prod}/{app,db,logs}
# 2. 创建用户组
# groupadd dev-team
# groupadd test-team
# groupadd prod-team
# 3. 设置目录所有权和权限
# 开发环境
# chown -R root:dev-team /project/dev
# chmod -R 2775 /project/dev
# find /project/dev -type d -exec chmod 2775 {} \;
# find /project/dev -type f -exec chmod 664 {} \;
# 测试环境
# chown -R root:test-team /project/test
# chmod -R 2775 /project/test
# 生产环境
# chown -R root:prod-team /project/prod
# chmod -R 2755 /project/prod
# 4. 验证权限设置
# ls -ld /project/dev /project/test /project/prod
drwxrwsr-x. 5 root dev-team 47 Apr 2 10:00 /project/dev
drwxrwsr-x. 5 root test-team 47 Apr 2 10:00 /project/test
drwxr-sr-x. 5 root prod-team 47 Apr 2 10:00 /project/prod
# 5. 添加用户到组
# gpasswd -a dev001 dev-team
# gpasswd -a dev002 dev-team
# gpasswd -a ops001 test-team
# gpasswd -a ops002 prod-team
# 6. 测试用户权限
# su – dev001
$ touch /project/dev/app/test.txt
$ ls -l /project/dev/app/test.txt
-rw-r–r–. 1 dev001 dev-team 0 Apr 2 10:00 /project/dev/app/test.txt
# 7. 设置SGID目录（新文件继承组）
# mkdir /shared/projectA
# chown root:dev-team /shared/projectA
# chmod 2775 /shared/projectA
# ls -ld /shared/projectA
drwxrwsr-x. 2 root dev-team 6 Apr 2 10:00 /shared/projectA
# 测试SGID效果
# su – dev001
$ touch /shared/projectA/file.txt
$ ls -l /shared/projectA/file.txt
-rw-r–r–. 1 dev001 dev-team 0 Apr 2 10:00 /shared/projectA/file.txt
# 8. 设置ACL权限（更精细的权限控制）
# setfacl -m g:dev-team:rwx /project/prod/app
# setfacl -m g:test-team:rx /project/prod/app
# getfacl /project/prod/app
# file: project/prod/app
# owner: root
# group: root
# flags: -s-
user::rwx
group::r-x
group:dev-team:rwx
group:test-team:r-x
mask::rwx
other::r-x
# 9. 设置只读组
# groupadd readonly
# setfacl -m g:readonly:rx /project/prod/app
# gpasswd -a auditor readonly
# 10. 设置拒绝访问组
# groupadd noaccess
# setfacl -m g:noaccess:— /project/prod/db
# gpasswd -a tempuser noaccess
# 11. 验证权限设置
# su – auditor
$ ls /project/prod/app
file1.txt file2.txt
$ touch /project/prod/app/test.txt
touch: cannot touch ‘/project/prod/app/test.txt’: Permission denied
# 12. 创建权限管理脚本
# cat > /tmp/setup_project_permissions.sh << 'EOF'
#!/bin/bash
PROJECT_DIR="/project"
# 创建目录结构
mkdir -p $PROJECT_DIR/{dev,test,prod}/{app,db,logs}
# 设置开发环境权限
chown -R root:dev-team $PROJECT_DIR/dev
chmod -R 2775 $PROJECT_DIR/dev
find $PROJECT_DIR/dev -type d -exec chmod 2775 {} \;
find $PROJECT_DIR/dev -type f -exec chmod 664 {} \;
# 设置测试环境权限
chown -R root:test-team $PROJECT_DIR/test
chmod -R 2775 $PROJECT_DIR/test
find $PROJECT_DIR/test -type d -exec chmod 2775 {} \;
find $PROJECT_DIR/test -type f -exec chmod 664 {} \;
# 设置生产环境权限
chown -R root:prod-team $PROJECT_DIR/prod
chmod -R 2755 $PROJECT_DIR/prod
find $PROJECT_DIR/prod -type d -exec chmod 2755 {} \;
find $PROJECT_DIR/prod -type f -exec chmod 644 {} \;
echo "Project permissions configured successfully"
EOF
# chmod +x /tmp/setup_project_permissions.sh
# /tmp/setup_project_permissions.sh
Project permissions configured successfully
4.3 用户组审计案例
定期审计用户组是系统安全的重要环节。
# 1. 创建用户组审计脚本
# cat > /tmp/group_audit.sh << 'EOF'
#!/bin/bash
REPORT="/tmp/group_audit_report.txt"
echo "========================================" > $REPORT
echo “Group Audit Report – $(date)” >> $REPORT
echo “========================================” >> $REPORT
echo “” >> $REPORT
# 1. 统计用户组总数
echo “1. Group Statistics” >> $REPORT
echo “——————–” >> $REPORT
total_groups=$(cat /etc/group | wc -l)
normal_groups=$(awk -F: ‘$3 >= 1000 && $3 != 65534 {print}’ /etc/group | wc -l)
system_groups=$(awk -F: ‘$3 < 1000 {print}' /etc/group | wc -l)
echo "Total groups: $total_groups" >> $REPORT
echo “Normal groups: $normal_groups” >> $REPORT
echo “System groups: $system_groups” >> $REPORT
echo “” >> $REPORT
# 2. 检查GID为0的组
echo “2. GID 0 Groups (Root Privileges)” >> $REPORT
echo “———————————-” >> $REPORT
awk -F: ‘$3 == 0 {print $1}’ /etc/group >> $REPORT
echo “” >> $REPORT
# 3. 检查空组（无成员）
echo “3. Empty Groups (No Members)” >> $REPORT
echo “—————————–” >> $REPORT
for group in $(awk -F: ‘$3 >= 1000 {print $1}’ /etc/group); do
members=$(groupmems -g $group -l 2>/dev/null)
if [ -z “$members” ]; then
echo “$group” >> $REPORT
fi
done
echo “” >> $REPORT
# 4. 检查重复GID
echo “4. Duplicate GIDs” >> $REPORT
echo “——————” >> $REPORT
awk -F: ‘{print $3}’ /etc/group | sort | uniq -d | while read gid; do
awk -F: -v gid=$gid ‘$3 == gid {print $1, $3}’ /etc/group >> $REPORT
done
echo “” >> $REPORT
# 5. 检查特权组成员
echo “5. Privileged Group Members” >> $REPORT
echo “—————————-” >> $REPORT
for group in wheel root sudo; do
if grep -q “^$group:” /etc/group; then
echo “Group: $group” >> $REPORT
groupmems -g $group -l 2>/dev/null >> $REPORT
echo “” >> $REPORT
fi
done
# 6. 检查组成员数量
echo “6. Group Member Count” >> $REPORT
echo “———————-” >> $REPORT
for group in $(awk -F: ‘$3 >= 1000 {print $1}’ /etc/group); do
count=$(groupmems -g $group -l 2>/dev/null | wc -w)
echo “$group: $count members” >> $REPORT
done
echo “” >> $REPORT
# 7. 检查组密码
echo “7. Groups with Passwords” >> $REPORT
echo “————————-” >> $REPORT
awk -F: ‘$2 != “” && $2 != “!” && $2 != “!!” {print $1}’ /etc/gshadow >> $REPORT
echo “” >> $REPORT
# 8. 检查组管理员
echo “8. Groups with Administrators” >> $REPORT
echo “——————————” >> $REPORT
awk -F: ‘$3 != “” {print $1, “Admin:”, $3}’ /etc/gshadow >> $REPORT
echo “” >> $REPORT
# 9. 检查用户主组
echo “9. User Primary Groups” >> $REPORT
echo “———————–” >> $REPORT
awk -F: ‘$3 >= 1000 && $3 != 65534 {print $1, “Primary GID:”, $4}’ /etc/passwd >> $REPORT
echo “” >> $REPORT
# 10. 检查用户附加组
echo “10. User Supplementary Groups” >> $REPORT
echo “——————————” >> $REPORT
for user in $(awk -F: ‘$3 >= 1000 && $3 != 65534 {print $1}’ /etc/passwd); do
groups=$(id -Gn $user | cut -d’ ‘ -f2-)
if [ -n “$groups” ]; then
echo “$user: $groups” >> $REPORT
fi
done
echo “” >> $REPORT
echo “Audit completed. Report saved to $REPORT”
EOF
# 2. 执行审计脚本
# chmod +x /tmp/group_audit.sh
# /tmp/group_audit.sh
Audit completed. Report saved to /tmp/group_audit_report.txt
# 3. 查看审计报告
# cat /tmp/group_audit_report.txt
========================================
Group Audit Report – Fri Apr 2 10:00:00 CST 2026
========================================
1. Group Statistics
——————–
Total groups: 50
Normal groups: 10
System groups: 40
2. GID 0 Groups (Root Privileges)
———————————-
root
3. Empty Groups (No Members)
—————————–
testgroup
oldgroup
4. Duplicate GIDs
——————
5. Privileged Group Members
—————————-
Group: wheel
fgedu dev001 dev002
6. Group Member Count
———————-
developers: 3 members
ops: 2 members
dba: 1 member
security: 2 members
docker: 3 members
7. Groups with Passwords
————————-
8. Groups with Administrators
——————————
wheel Admin: fgedu
9. User Primary Groups
———————–
fgedu Primary GID: 1000
dev001 Primary GID: 1001
dev002 Primary GID: 1001
ops001 Primary GID: 1002
dba001 Primary GID: 1003
10. User Supplementary Groups
——————————
fgedu: wheel docker
dev001: wheel docker developers
dev002: wheel docker developers
ops001: wheel docker ops
dba001: dba
Part05-风哥经验总结与分享
5.1 用户组管理最佳实践
# 1. 用户组创建规范
– 使用统一的命名规范
– 指定合适的GID
– 添加组描述信息
– 设置组密码（特权组）
– 设置组管理员
# 2. 用户组权限管理
– 使用SGID实现文件共享
– 使用ACL实现精细权限
– 定期审计组权限
– 避免过度授权
– 记录权限变更日志
# 3. 用户组生命周期管理
– 创建：规划组名、GID、成员
– 维护：定期审计、调整成员
– 删除：清理成员、检查文件、删除组
# 4. 用户组安全审计
– 定期检查组列表
– 检查特权组成员
– 检查空组
– 检查组密码
– 检查组权限
# 5. 用户组管理自动化
– 使用脚本批量创建组
– 使用配置管理工具（Ansible）
– 建立用户组管理流程
– 记录用户组变更日志
– 定期生成审计报告
5.2 常见问题与解决
# 问题1：用户组创建失败
# groupadd developers
groupadd: group ‘developers’ already exists
# 解决：检查用户组是否存在
# grep “developers” /etc/group
developers:x:1001:
# 问题2：GID已被使用
# groupadd -g 1001 testgroup
groupadd: GID ‘1001’ already exists
# 解决：使用其他GID或强制创建
# groupadd -g 1002 testgroup
# 或
# groupadd -o -g 1001 testgroup
# 问题3：无法删除用户组
# groupdel developers
groupdel: cannot remove the primary group of user ‘dev001’
# 解决：修改用户主组
# usermod -g users dev001
# groupdel developers
# 问题4：用户组权限不生效
# ls -ld /data/app
drwxrwxr-x. 2 root developers 6 Apr 2 10:00 /data/app
# 解决：检查用户是否在组内
# groups dev001
dev001 : dev001 wheel
# 添加用户到组
# gpasswd -a dev001 developers
# 需要重新登录生效
# 问题5：SGID不生效
# mkdir /shared
# chmod 2775 /shared
# ls -ld /shared
drwxrwsr-x. 2 root root 6 Apr 2 10:00 /shared
# 解决：设置组所有权
# chown root:developers /shared
# ls -ld /shared
drwxrwsr-x. 2 root developers 6 Apr 2 10:00 /shared
# 问题6：组成员过多
# groupmems -g wheel -l | wc -w
50
# 解决：审计并移除不必要的成员
# gpasswd -d tempuser wheel
# 问题7：组密码丢失
# grep “^wheel:” /etc/gshadow
wheel:!::
# 解决：重新设置组密码
# gpasswd wheel
Changing the password for group wheel
New Password:
Re-enter new password:
# 问题8：组管理员无法管理
# gpasswd -A dev001 developers
# su – dev001
$ gpasswd -a dev002 developers
gpasswd: Permission denied
# 解决：检查组管理员权限
# grep “^developers:” /etc/gshadow
developers:$6$xxx:dev001:
# 问题9：用户主组丢失
# id dev001
id: cannot find name for group ID 1001
# 解决：重建用户组
# groupadd -g 1001 developers
# 问题10：组文件权限错误
# ls -l /etc/group /etc/gshadow
-rw-r–r–. 1 root root 1234 Apr 2 10:00 /etc/group
-rw-r–r–. 1 root root 1234 Apr 2 10:00 /etc/gshadow
# 解决：修复权限
# chmod 644 /etc/group
# chmod 400 /etc/gshadow
5.3 用户组管理工具推荐
- 命令行工具：groupadd, groupmod, groupdel, gpasswd, groupmems
- 图形化工具：system-config-users（RHEL）
- 配置管理：Ansible group module
- 集中管理：LDAP, FreeIPA, Active Directory
- 审计工具：groupmems, getent, lid
# 1. 创建Ansible playbook
# cat > /tmp/manage_groups.yml << 'EOF'
---
- name: Manage Groups
hosts: all
become: yes
vars:
groups:
- name: developers
gid: 1001
state: present
- name: ops
gid: 1002
state: present
- name: dba
gid: 1003
state: present
tasks:
- name: Create groups
group:
name: "{{ item.name }}"
gid: "{{ item.gid }}"
state: "{{ item.state }}"
loop: "{{ groups }}"
- name: Add users to groups
user:
name: "{{ item.user }}"
groups: "{{ item.groups }}"
append: yes
loop:
- { user: 'dev001', groups: 'developers,wheel' }
- { user: 'dev002', groups: 'developers,wheel' }
- { user: 'ops001', groups: 'ops,wheel' }
EOF
# 2. 执行Ansible playbook
# ansible-playbook -i inventory /tmp/manage_groups.yml
# 3. 使用Ansible ad-hoc命令创建组
# ansible all -m group -a "name=testgroup gid=2000 state=present" -b
# 4. 使用Ansible删除组
# ansible all -m group -a "name=testgroup state=absent" -b
本文由风哥教程整理发布,仅用于学习测试使用,转载注明出处:http://www.fgedu.net.cn/10327.html
联系我们
在线咨询：
微信号：itpux-com
工作日：9:30-18:30，节假日休息
