How to Configure Greenplum User Roles
You configure greenplum user roles by creating cluster-wide accounts and assigning group privileges. Admins then link these roles to host login rules and schema permissions. Most data teams start by creating broad role groups for analysts and engineers. They grant read or write rights across whole schemas to save time. Overly broad roles soon let users run heavy queries or read private tables. One shared password can expose sensitive customer data to the whole team. How greenplum user roles wo
Your coding agents run with your access.
Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.
You configure greenplum user roles by creating cluster-wide accounts and assigning group privileges. Admins then link these roles to host login rules and schema permissions. Most data teams start by creating broad role groups for analysts and engineers. They grant read or write rights across whole schemas to save time. Overly broad roles soon let users run heavy queries or read private tables. One shared password can expose sensitive customer data to the whole team.
How greenplum user roles work at the cluster level
Greenplum manages users and groups through a single concept called a role. Every role lives at the system level across the whole database cluster. A role can act as a single user, a group, or both. When you create a role for a person, you enable login rights. When you create a role for a team, you disable login rights. You then grant the team role to each person on that team.
Permissions flow down from the group role to each member role. You assign object rights on schemas, tables, and views to the group. You also set resource queues on roles to cap memory and CPU use. Host config files on the coordinator node check where users log in from. The coordinator checks the user role, client IP address, and login method. Once the coordinator approves the login, the user can query allowed tables.
Admins also set default permissions for new tables created inside a schema. Without default rules, only the table owner can read the new table. Setting up role inheritance lets team members read new tables right away. This model keeps day-to-day table grants simple as your data warehouse grows.
Why static role grants fall short during live sessions
Native database roles do a good job of controlling who logs in. They also draw clear lines between different schemas and tables at rest. Still, static roles cannot inspect or control individual statements in flight. Once a user logs in with a role, those permissions stay active. The user keeps full access until an admin revokes the grant manually.
This gap causes trouble when engineers need quick access to fix production bugs. Teams often grant superuser or write roles and forget to remove them. Static table grants also fail when a table mixes public and private columns. If a role can read a customer table, it pulls every field. Results return raw emails, phone numbers, card numbers, and national IDs in plain text. Native roles cannot rewrite matched fields in results without complex custom views.
User Provisioning (SCIM) + Lambda Execution Roles: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Also, shared role credentials make audit logs very hard to read later. The database log shows the role name, not the real person behind it. Security teams cannot tell which engineer ran a drop statement or export.
Best practices for structuring warehouse role hierarchies
Start by separating human users from automated service accounts in your cluster. Give every person a unique login role tied to your central directory. Never let two people or two apps share the same login role. Next, build functional group roles based on job duties, like finance readers. Grant schema and table rights only to these group roles, never to individuals.
Keep superuser roles locked down and out of daily workflows. Use resource groups on every role so one bad query cannot freeze the cluster. Review role memberships every month to remove old accounts and unused privileges. When users need temporary write rights, require peer approval before running the change.
Add runtime guardrails and masking beside your databases and APIs
Login rules, role grants, and CI checks govern who connects to your stack. Yet any allowed script, engineer, or AI agent still runs commands with the full scope of its role. For workloads on Postgres, MySQL, SQL Server, MongoDB, ClickHouse, Kubernetes, SSH, or internal HTTP services, hoop.dev sits inline in the protocol beside the service as an open-source proxy, a sidecar for your database or API. On every production query an agent or human runs, hoop.dev decides whether to pass, mask, block, or escalate it for review.
Before a query runs, hoop.dev guardrails check the statement against your rules, an AI Analyzer you configure can score intent or hold risky calls for human approval, and hoop.dev data masking rewrites sensitive fields in responses in memory. Explore the MIT-licensed project on GitHub.
Frequently asked questions
What is the difference between a user and a role in Greenplum?
Greenplum treats users and groups as the exact same object called a role. A user is simply a role that has permission to log in.
Do Greenplum roles apply to a single database or the whole cluster?
Roles exist at the cluster level and span across all databases inside it. Still, table and schema grants still apply to one specific database at a time.
How do you limit query memory for a specific Greenplum role?
You assign the role to a dedicated resource queue or resource group. That group sets hard limits on memory, CPU cores, and active query counts.
Related guides
In this post