蜷缩的蜗牛
蜷缩的蜗牛

Grafana与PostgreSQL集成故障排查指南

云原生运维 收录于 监控  数据库
 约 4900 字 预计阅读 10 分钟 - 次阅读  

1. 概述

Grafana是一个流行的开源可视化和监控平台，可以与多种数据库集成，包括PostgreSQL。在生产环境中，使用PostgreSQL作为Grafana的后端数据库是一种常见的高可用配置。然而，在集成过程中可能会遇到各种问题，其中最常见的是与数据库角色和权限相关的错误，特别是"role does not exist"（角色不存在）错误。

本文将详细介绍Grafana与PostgreSQL集成过程中常见的问题和解决方案，特别是针对角色不存在错误的全面排查指南。

2. 常见错误类型

2.1 “role does not exist"错误

这是最常见的错误之一，通常在以下情况下出现：

1
2

ERROR: role "grafana" does not exist
STATEMENT: ALTER TABLE public.alert OWNER TO grafana;

这个错误表明PostgreSQL数据库中不存在名为"grafana"的角色，但Grafana正在尝试将表的所有权分配给这个不存在的角色。

2.2 权限不足错误 

1
2

ERROR: permission denied for schema public
STATEMENT: CREATE TABLE public.dashboard (...);

这个错误表明grafana角色没有在public schema中创建表的权限。

2.3 连接错误 

1

ERROR: password authentication failed for user "grafana"

这个错误表明提供的密码与PostgreSQL中grafana用户的密码不匹配。

3. 错误原因分析

3.1 “role does not exist"错误的原因

  1. 角色创建失败：在初始化PostgreSQL数据库时，没有创建grafana角色。
  2. 角色名称不匹配：Grafana配置中使用的数据库用户名与PostgreSQL中创建的角色名不一致。
  3. 权限问题：创建角色的用户没有足够的权限。
  4. 初始化顺序问题：Grafana在PostgreSQL完全准备好之前就尝试连接和创建表。
  5. Docker/Kubernetes环境问题：在容器化环境中，初始化脚本可能没有正确执行。

3.2 权限不足错误的原因

  1. 权限配置不完整：grafana角色没有被授予足够的权限。
  2. Schema所有权问题：public schema的所有者不是grafana角色，且没有授予适当的权限。
  3. PostgreSQL安全设置：PostgreSQL的安全设置限制了角色的操作。

3.3 连接错误的原因

  1. 密码不匹配：配置中的密码与数据库中设置的密码不一致。
  2. 网络问题：Grafana无法连接到PostgreSQL服务器。
  3. PostgreSQL配置问题：pg_hba.conf文件中没有允许grafana用户连接。

4. 排查方法

4.1 检查PostgreSQL角色

首先，检查PostgreSQL中是否存在grafana角色：

1
2
3
4
5
6
7
8

# 连接到PostgreSQL
sudo -u postgres psql

# 列出所有角色
\du

# 检查特定角色
SELECT rolname FROM pg_roles WHERE rolname = 'grafana';

4.2 检查数据库权限 

1
2
3
4
5
6
7
8

# 连接到grafana数据库
\c grafana

# 检查表的所有权
\dt

# 检查schema权限
\dn+

4.3 检查Grafana配置

检查Grafana的数据库配置（通常在grafana.ini文件中）：

1
2
3
4
5
6

[database]
type = postgres
host = localhost:5432
name = grafana
user = grafana
password = your_password

或者检查环境变量：

1
2

echo $GF_DATABASE_USER
echo $GF_DATABASE_PASSWORD

4.4 检查连接问题 

1
2
3
4
5

# 尝试使用grafana角色连接到PostgreSQL
psql -h localhost -U grafana -d grafana

# 检查PostgreSQL日志
tail -f /var/log/postgresql/postgresql-13-main.log

4.5 检查容器化环境

如果在Docker或Kubernetes环境中运行：

1
2
3
4
5
6
7
8
9

# 检查PostgreSQL容器日志
docker logs postgres-container

# 检查Grafana容器日志
docker logs grafana-container

# 在Kubernetes中
kubectl logs -n monitoring deployment/postgres
kubectl logs -n monitoring deployment/grafana

5. 解决方案

5.1 创建缺失的角色 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 连接到PostgreSQL
sudo -u postgres psql

# 创建grafana角色
CREATE ROLE grafana WITH LOGIN PASSWORD 'your_secure_password';

# 授予权限
GRANT ALL PRIVILEGES ON DATABASE grafana TO grafana;

# 连接到grafana数据库
\c grafana

# 设置schema权限
GRANT ALL PRIVILEGES ON SCHEMA public TO grafana;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO grafana;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO grafana;

5.2 修复表的所有权 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 连接到grafana数据库
sudo -u postgres psql -d grafana

# 修复表的所有权
DO $$
DECLARE
    t record;
BEGIN
    FOR t IN SELECT tablename FROM pg_tables WHERE schemaname = 'public'
    LOOP
        EXECUTE 'ALTER TABLE public.' || quote_ident(t.tablename) || ' OWNER TO grafana';
    END LOOP;
END
$$;

# 修复序列的所有权
DO $$
DECLARE
    s record;
BEGIN
    FOR s IN SELECT sequence_name FROM information_schema.sequences WHERE sequence_schema = 'public'
    LOOP
        EXECUTE 'ALTER SEQUENCE public.' || quote_ident(s.sequence_name) || ' OWNER TO grafana';
    END LOOP;
END
$$;

5.3 使用修复脚本

我们提供了一个全面的修复脚本，可以自动解决大多数角色和权限问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#!/bin/bash

# PostgreSQL连接信息
PG_HOST="localhost"
PG_PORT="5432"
PG_USER="postgres"
PG_PASSWORD="your_postgres_password"
PG_DB="postgres"
GRAFANA_DB="grafana"
GRAFANA_ROLE="grafana"
GRAFANA_PASSWORD="your_grafana_password"

# 设置PGPASSWORD环境变量
export PGPASSWORD="$PG_PASSWORD"

# 检查grafana角色是否存在
ROLE_EXISTS=$(psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -tAc "SELECT 1 FROM pg_roles WHERE rolname='$GRAFANA_ROLE'")

if [ -z "$ROLE_EXISTS" ]; then
    echo "创建grafana角色..."
    psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -c "CREATE ROLE $GRAFANA_ROLE WITH LOGIN PASSWORD '$GRAFANA_PASSWORD';"
else
    echo "更新grafana角色密码..."
    psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -c "ALTER ROLE $GRAFANA_ROLE WITH LOGIN PASSWORD '$GRAFANA_PASSWORD';"
fi

# 检查grafana数据库是否存在
DB_EXISTS=$(psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -tAc "SELECT 1 FROM pg_database WHERE datname='$GRAFANA_DB'")

if [ -z "$DB_EXISTS" ]; then
    echo "创建grafana数据库..."
    psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -c "CREATE DATABASE $GRAFANA_DB;"
fi

# 授予权限
echo "授予权限..."
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $PG_DB -c "GRANT ALL PRIVILEGES ON DATABASE $GRAFANA_DB TO $GRAFANA_ROLE;"
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $GRAFANA_DB -c "GRANT ALL PRIVILEGES ON SCHEMA public TO $GRAFANA_ROLE;"
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $GRAFANA_DB -c "ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO $GRAFANA_ROLE;"
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $GRAFANA_DB -c "ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO $GRAFANA_ROLE;"

# 修复表的所有权
echo "修复表的所有权..."
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $GRAFANA_DB -c "DO \$\$
DECLARE
    t record;
BEGIN
    FOR t IN SELECT tablename FROM pg_tables WHERE schemaname = 'public'
    LOOP
        EXECUTE 'ALTER TABLE public.' || quote_ident(t.tablename) || ' OWNER TO $GRAFANA_ROLE';
    END LOOP;
END
\$\$;"

# 修复序列的所有权
echo "修复序列的所有权..."
psql -h $PG_HOST -p $PG_PORT -U $PG_USER -d $GRAFANA_DB -c "DO \$\$
DECLARE
    s record;
BEGIN
    FOR s IN SELECT sequence_name FROM information_schema.sequences WHERE sequence_schema = 'public'
    LOOP
        EXECUTE 'ALTER SEQUENCE public.' || quote_ident(s.sequence_name) || ' OWNER TO $GRAFANA_ROLE';
    END LOOP;
END
\$\$;"

echo "角色修复完成！"

5.4 在Kubernetes中使用Job修复

对于Kubernetes环境，可以使用Job来修复角色问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

apiVersion: batch/v1
kind: Job
metadata:
  name: postgres-role-fix
  namespace: monitoring
spec:
  template:
    spec:
      containers:
      - name: postgres-client
        image: postgres:13
        command: ["bash", "-c"]
        args:
        - |
          # 等待PostgreSQL服务可用
          until PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -c '\q'; do
            echo "PostgreSQL服务不可用 - 等待..."
            sleep 2
          done
          
          # 检查grafana角色是否存在
          ROLE_EXISTS=$(PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -tAc "SELECT 1 FROM pg_roles WHERE rolname='grafana'")
          
          if [ -z "$ROLE_EXISTS" ]; then
            echo "创建grafana角色..."
            PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -c "CREATE ROLE grafana WITH LOGIN PASSWORD '$GRAFANA_PASSWORD';"
          else
            echo "更新grafana角色密码..."
            PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -c "ALTER ROLE grafana WITH LOGIN PASSWORD '$GRAFANA_PASSWORD';"
          fi
          
          # 检查grafana数据库是否存在
          DB_EXISTS=$(PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -tAc "SELECT 1 FROM pg_database WHERE datname='grafana'")
          
          if [ -z "$DB_EXISTS" ]; then
            echo "创建grafana数据库..."
            PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -c "CREATE DATABASE grafana;"
          fi
          
          # 授予权限
          echo "授予权限..."
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d postgres -c "GRANT ALL PRIVILEGES ON DATABASE grafana TO grafana;"
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d grafana -c "GRANT ALL PRIVILEGES ON SCHEMA public TO grafana;"
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d grafana -c "ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO grafana;"
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d grafana -c "ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO grafana;"
          
          # 修复表的所有权
          echo "修复表的所有权..."
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d grafana -c "DO \\$\\$
          DECLARE
              t record;
          BEGIN
              FOR t IN SELECT tablename FROM pg_tables WHERE schemaname = 'public'
              LOOP
                  EXECUTE 'ALTER TABLE public.' || quote_ident(t.tablename) || ' OWNER TO grafana';
              END LOOP;
          END
          \\$\\$;"
          
          # 修复序列的所有权
          echo "修复序列的所有权..."
          PGPASSWORD=$POSTGRES_PASSWORD psql -h $POSTGRES_HOST -U $POSTGRES_USER -d grafana -c "DO \\$\\$
          DECLARE
              s record;
          BEGIN
              FOR s IN SELECT sequence_name FROM information_schema.sequences WHERE sequence_schema = 'public'
              LOOP
                  EXECUTE 'ALTER SEQUENCE public.' || quote_ident(s.sequence_name) || ' OWNER TO grafana';
              END LOOP;
          END
          \\$\\$;"
          
          echo "角色修复完成！"
        env:
        - name: POSTGRES_HOST
          value: "postgres-service"
        - name: POSTGRES_USER
          value: "postgres"
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: postgres-password
        - name: GRAFANA_PASSWORD
          valueFrom:
            secretKeyRef:
              name: grafana-secret
              key: grafana-password
      restartPolicy: Never
  backoffLimit: 3

5.5 在Docker环境中使用初始化脚本

在Docker环境中，可以使用初始化脚本在容器启动时自动创建角色和设置权限：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

version: '3.8'

services:
  postgres:
    image: postgres:13
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres_password
      POSTGRES_DB: postgres
      GRAFANA_PASSWORD: grafana_password
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init-grafana-db.sh:/docker-entrypoint-initdb.d/init-grafana-db.sh:ro
    ports:
      - "5432:5432"

  grafana:
    image: grafana/grafana:latest
    depends_on:
      - postgres
    environment:
      GF_DATABASE_TYPE: postgres
      GF_DATABASE_HOST: postgres:5432
      GF_DATABASE_NAME: grafana
      GF_DATABASE_USER: grafana
      GF_DATABASE_PASSWORD: grafana_password
    ports:
      - "3000:3000"

volumes:
  postgres-data:

创建初始化脚本 init-grafana-db.sh：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#!/bin/bash
set -e

psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
    -- 创建grafana角色（如果不存在）
    DO \$\$ 
    BEGIN
        IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'grafana') THEN
            CREATE ROLE grafana WITH LOGIN PASSWORD '${GRAFANA_PASSWORD:-grafana_password}';
        ELSE
            -- 更新现有角色的密码
            ALTER ROLE grafana WITH LOGIN PASSWORD '${GRAFANA_PASSWORD:-grafana_password}';
        END IF;
    END
    \$\$;

    -- 创建grafana数据库（如果不存在）
    SELECT 'CREATE DATABASE grafana'
    WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = 'grafana')
    \gexec

    -- 授予grafana角色对grafana数据库的所有权限
    GRANT ALL PRIVILEGES ON DATABASE grafana TO grafana;
    
    -- 连接到grafana数据库以设置schema权限
    \c grafana
    
    -- 授予grafana角色对public schema的所有权限
    GRANT ALL PRIVILEGES ON SCHEMA public TO grafana;
    
    -- 设置默认权限，使grafana角色成为未来创建的表的所有者
    ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO grafana;
    ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO grafana;
    ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON FUNCTIONS TO grafana;
    
    -- 创建触发器函数，自动将新表的所有权分配给grafana角色
    CREATE OR REPLACE FUNCTION assign_ownership_to_grafana()
    RETURNS event_trigger AS \$\$
    DECLARE
        obj record;
    BEGIN
        FOR obj IN SELECT * FROM pg_event_trigger_ddl_commands() WHERE command_tag IN ('CREATE TABLE', 'CREATE SEQUENCE')
        LOOP
            IF obj.object_type IN ('table', 'sequence') THEN
                EXECUTE format('ALTER %s %s OWNER TO grafana', obj.object_type, obj.object_identity);
            END IF;
        END LOOP;
    END;
    \$\$ LANGUAGE plpgsql;

    -- 创建事件触发器
    DO \$\$
    BEGIN
        IF NOT EXISTS (SELECT 1 FROM pg_event_trigger WHERE evtname = 'grafana_ownership_trigger') THEN
            CREATE EVENT TRIGGER grafana_ownership_trigger ON ddl_command_end
            WHEN TAG IN ('CREATE TABLE', 'CREATE SEQUENCE')
            EXECUTE PROCEDURE assign_ownership_to_grafana();
        END IF;
    EXCEPTION
        WHEN insufficient_privilege THEN
            RAISE NOTICE 'Skipping event trigger creation due to insufficient privileges';
    END
    \$\$;
EOSQL

6. 预防措施

6.1 正确的初始化顺序

  1. 首先创建PostgreSQL数据库和角色
  2. 设置适当的权限
  3. 然后启动Grafana并配置使用PostgreSQL

6.2 使用依赖检查

在Docker Compose中使用健康检查确保PostgreSQL完全准备好：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

services:
  postgres:
    # ... 其他配置 ...
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  grafana:
    # ... 其他配置 ...
    depends_on:
      postgres:
        condition: service_healthy

6.3 使用初始化容器

在Kubernetes中，使用初始化容器确保数据库准备就绪：

1
2
3
4
5

spec:
  initContainers:
  - name: wait-for-postgres
    image: postgres:13
    command: ['sh', '-c', 'until pg_isready -h postgres -U postgres; do echo waiting for postgres; sleep 2; done;']

6.4 定期备份

定期备份PostgreSQL数据库，以防出现问题时可以恢复：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 创建备份脚本
cat > /usr/local/bin/backup-grafana-db.sh << 'EOF'
#!/bin/bash

BACKUP_DIR="/var/backups/grafana"
DATETIME=$(date +"%Y%m%d-%H%M%S")
BACKUP_FILE="$BACKUP_DIR/grafana-$DATETIME.sql"

# 创建备份目录
mkdir -p "$BACKUP_DIR"

# 执行备份
pg_dump -h localhost -U grafana -d grafana -f "$BACKUP_FILE"

# 压缩备份文件
gzip "$BACKUP_FILE"

# 删除30天前的备份
find "$BACKUP_DIR" -name "grafana-*.sql.gz" -mtime +30 -delete
EOF

# 设置执行权限
chmod +x /usr/local/bin/backup-grafana-db.sh

# 添加到crontab
(crontab -l 2>/dev/null; echo "0 2 * * * /usr/local/bin/backup-grafana-db.sh") | crontab -

7. Grafana特定配置

7.1 配置文件设置

在grafana.ini文件中正确配置数据库连接：

1
2
3
4
5
6
7

[database]
type = postgres
host = localhost:5432
name = grafana
user = grafana
password = your_secure_password
ssl_mode = disable

7.2 环境变量设置

使用环境变量配置Grafana：

1
2
3
4
5
6

export GF_DATABASE_TYPE=postgres
export GF_DATABASE_HOST=localhost:5432
export GF_DATABASE_NAME=grafana
export GF_DATABASE_USER=grafana
export GF_DATABASE_PASSWORD=your_secure_password
export GF_DATABASE_SSL_MODE=disable

7.3 Docker环境变量

在Docker环境中使用环境变量：

1
2
3
4
5
6
7

environment:
  GF_DATABASE_TYPE: postgres
  GF_DATABASE_HOST: postgres:5432
  GF_DATABASE_NAME: grafana
  GF_DATABASE_USER: grafana
  GF_DATABASE_PASSWORD: grafana_password
  GF_DATABASE_SSL_MODE: disable

8. 常见问题解答

8.1 为什么会出现"role does not exist"错误？

这个错误通常是因为Grafana尝试将表的所有权分配给一个不存在的PostgreSQL角色。在Grafana初始化数据库时，它会尝试创建表并将表的所有权分配给配置中指定的数据库用户。如果这个用户在PostgreSQL中不存在，就会出现这个错误。

8.2 如何检查PostgreSQL中的角色？

连接到PostgreSQL并运行以下命令：

1

SELECT rolname FROM pg_roles;

8.3 如何修复已经出现的错误？

  1. 创建缺失的角色
  2. 授予适当的权限
  3. 修复表的所有权
  4. 重启Grafana服务

8.4 如何在Docker环境中解决这个问题？

使用初始化脚本在PostgreSQL容器启动时自动创建角色和设置权限，并确保Grafana容器在PostgreSQL完全准备好之后才启动。

8.5 如何在Kubernetes环境中解决这个问题？

使用初始化容器或Job来确保PostgreSQL数据库和角色在Grafana启动之前已经正确设置。

9. 结论

Grafana与PostgreSQL的集成可能会遇到各种问题，特别是与数据库角色和权限相关的错误。通过本文提供的排查方法和解决方案，您应该能够解决大多数常见问题，特别是"role does not exist"错误。

记住，预防胜于治疗。在设置Grafana和PostgreSQL时，确保按照正确的顺序进行初始化，并使用适当的依赖检查和初始化脚本，可以避免大多数问题的发生。

10. 参考资料

更新于 2023-07-26 
CC BY-NC 4.0
阅读原始文档
LINE Myspace
GrafanaPostgreSQL故障排查
返回 | 主页
0%