FreeIPA vs 389 Directory Server

FreeIPA is built on 389 Directory Server, so the decision is about scope: a plain LDAP directory or the full stack with Kerberos, a certificate authority, DNS and host policy.

On this page

FreeIPA vs 389 Directory Server: when a plain LDAP directory is enough

FreeIPA uses 389 Directory Server as its directory, so this choice is about scope, not engine. Both store users, groups, hosts and policies in the same LDAPv3 server. What you decide is whether you also want the Kerberos KDC, the Dogtag certificate authority, DNS and host policy that FreeIPA wraps around it, and whether you want to build and operate those pieces yourself. The bare 389 Directory Server fits when applications need an LDAP directory and little else. It suits a team that already runs its own certificate process, its own DNS and its own SSO layer, and that is comfortable writing the schema, provisioning scripts and ACIs that the directory needs. 389 Directory Server offers multi-supplier replication, online configuration through LDAP operations, and the dscreate, dsconf and dsidm tools for administration, so a skilled LDAP team can run it well on its own. It also has a conversion path: the openldap_to_ds command can migrate an OpenLDAP estate on a best-effort basis, though you should test what it carries over, including overlays.

FreeIPA fits when Linux hosts are the main consumers of identity. Kerberos single sign-on, central sudo and HBAC rules, an integrated CA issuing host and service certificates, and DNS that clients resolve against are all native to the product. Building those on bare LDAP means writing and supporting each one separately, with its own renewal, replication and security patching. FreeIPA's own deployment guidance also expects dedicated servers, at least two to three replicas per datacenter and careful handling of which replica runs PKI or DNS, so the operational load is real. Confirm the current release and patch line before you plan, since FreeIPA 4.13.4 fixed two CVEs in July 2026 (see the FreeIPA 4.13.4 release notes). The decision turns on three questions. First, which integrations must be native rather than assembled: if Kerberos, host policy or certificate issuance are requirements, the bare directory leaves them to you. Second, what skills you have in-house across LDAP schema, Kerberos and PKI. Third, how much you are willing to build and maintain yourself over the next several years. A DeployOpen scoping conversation usually starts with those three answers, and the written scope then sets the work and deliverables.

Which scenario points to FreeIPA and which to 389 Directory Server

This table maps common situations to the platform that fits better and the condition that decides it. Read each row as a question about your environment: if the condition holds, the named platform is the simpler path; if it does not, check the other column before committing.

ScenarioBetter fitCondition that decides it
LDAP back end for internal applications389 Directory ServerApplications only need bind, search and group lookups over LDAP and no Kerberos, host policy or certificates. The team designs the schema, ACIs and any self-service tooling itself.
Linux fleet needing Kerberos single sign-onFreeIPAUsers log in to many Linux hosts and services with one ticket-based credential. FreeIPA bundles the MIT Kerberos KDC, so the team does not assemble realms, principals and keytabs by hand.
Service certificates for internal hosts and servicesFreeIPAYou need certificates issued and renewed from an internal CA with an audit trail. FreeIPA includes the Dogtag CA, while the bare directory has no certificate authority and the team must add one.
Central sudo and HBAC rules across hostsFreeIPAAccess and privilege policy must be defined once and pushed to host groups. FreeIPA stores sudo and host-based access rules natively, whereas 389 Directory Server stores only the raw entries and you write the enforcement.
Coexistence with an Active Directory forestFreeIPALinux users must reach resources and AD users must reach Linux services. FreeIPA can set up a cross-forest trust, and the IPA DNS domain must not overlap any AD forest domain. A bare directory has no built-in trust path.
Migration from OpenLDAP389 Directory ServerThe goal is a standards-based LDAPv3 replacement with the same directory model. The openldap_to_ds tool converts on a best-effort basis, so verify schema, overlays and indexes in a test run. Choose FreeIPA only if you also want Kerberos and CA services in the same move.
Small team with no Kerberos need389 Directory ServerFew hosts, no SSO requirement across Linux services, and no certificate lifecycle to manage. A directory alone is smaller to run, but confirm that application logins do not depend on Kerberos or AD trusts later.
Multi-master replication for a directory-only service389 Directory ServerYour main requirement is replicated directory data across sites. 389 Directory Server offers asynchronous multi-supplier replication on its own. FreeIPA adds replica planning for DNS and PKI on top, which you only need if those services run.
Full identity stack with backup and host policy in one productFreeIPAYou want directory, Kerberos, CA, DNS and host policy under one backup and upgrade process. Plan replica counts and confirm backup restore procedures with the FreeIPA backup documentation before go-live.

How the FreeIPA stack and the bare directory are built

FreeIPA is not a separate directory product. It wraps 389 Directory Server with Kerberos, a certificate authority, client tooling and optional DNS and time services, and its deployment guidance shapes how many servers you run. The cards below separate what the bare directory gives you from what the full stack adds, so you can weigh the operating load against the services you actually need.

The 389 Directory Server core

The directory engine uses asynchronous multi-supplier replication, so writes can land on any supplier and propagate to the others. Schema, configuration and access controls can be changed online through LDAP operations without a restart. Day-to-day work is split across dscreate for instance creation, dsctl for local start, stop and backup, dsconf for configuration, dsidm for identity content and a Cockpit console. Check whether your team can run that toolset without FreeIPA's wrapper.

Kerberos and certificates on top

FreeIPA adds an MIT Kerberos KDC for single sign-on and a Dogtag certificate authority that issues certificates to hosts and services. The bare directory has neither, so Kerberos principals, keytabs and certificate lifecycle become work you build and maintain yourself. Confirm which of these you need on day one, because the CA and KDC are the parts that tie the topology to the replicas that hold them.

Client and service layer

SSSD runs on enrolled Linux clients and handles identity lookups, caching and Kerberos authentication against the server. Optional ISC BIND DNS and NTP can run alongside the servers, so host names and time sources are managed in the same deployment. If you already run DNS and time elsewhere, decide whether to keep them separate, since FreeIPA's guidance asks you to plan DNS redundancy in each client's resolver configuration.

Replica topology guidance

FreeIPA's deployment recommendations advise at least two to three replicas in each datacenter and no more than four replication agreements per replica. They also call for dedicated servers without other applications, and at least one replica per datacenter running PKI or DNS if you use those services. Use this as the sizing baseline for a quote: each extra datacenter multiplies replica count, and the bare directory has no equivalent of these services to place.

Packaging across distributions

FreeIPA is packaged for Fedora, Debian and CentOS, and as Identity Management in Red Hat Enterprise Linux. The 389 Directory Server core is packaged separately as 389-ds on openSUSE Leap 15 and Tumbleweed, and as 389-ds-base on Fedora and CentOS 8. Check your distribution's package name and support window before you pick a build, because the full stack and the bare directory may not come from the same repositories on your estate.

Capabilities that separate a FreeIPA install from a bare 389 Directory Server

This table lists the capabilities that a FreeIPA install adds on top of 389 Directory Server, and what the bare directory leaves to your team. Read each row as a question: if your estate needs the capability, the right column tells you whether you get it in the box or must design, build and operate it yourself. Note that the FreeIPA web UI first arrived as a beta in 4.13.0, and confirm current UI maturity against the release you plan to deploy.

CapabilityFreeIPA (bundled)Bare 389 Directory Server
LicenseGPL-3.0-or-later, community project with no paid editionGPLv3 code with CC BY-SA 4.0 documentation, no paid edition named in the facts
LDAP protocol supportLDAPv3 directory for users, groups, hosts and policies, built on 389 Directory ServerLDAPv3 compliant with TLS and SASL support
Kerberos single sign-onIncluded through an MIT Kerberos KDCNot included, must be deployed and integrated separately
Certificate authorityIntegrated Dogtag CA issues host and user certificatesNot included, requires an external or separately built CA
DNS and NTPOptional ISC BIND DNS and NTP components, DNS over TLS added in 4.13.0Not included, DNS and time services are managed outside the directory
Host, sudo and HBAC policyCentral host-based access control and sudo rules managed in the platformNot included, sudo and HBAC rules must be modeled and maintained by hand in LDAP
OTP two-factor (HOTP and TOTP)Software and hardware tokens, with OTP checks proxied to an existing RADIUS serverNot included, requires a separate OTP service or application
Multi-supplier replicationBuilt on 389 Directory Server replication, with FreeIPA topology guidance for replica counts per datacenterAsynchronous multi-supplier replication, with topology design left to your team
Online configurationManaged through FreeIPA tools and the web UI, which first arrived as a beta in 4.13.0Schema, configuration and ACIs updated online through LDAP operations with zero downtime
Migration toolingipa migrate-ds for users and groups, with sudo and HBAC rules migrated manually by LDIFopenldap_to_ds converts an OpenLDAP server on a best-effort basis
Active Directory cross-forest trustTrust through Samba components, requiring a non-overlapping IPA DNS domainNot included, AD trust must be designed on top of the directory
Administration toolingFreeIPA command line and web UI for identity, certificate and policy tasksdscreate, dsctl, dsconf and dsidm for instances, with a Cockpit web console

How replication and backups differ between the bare directory and FreeIPA

With a bare 389 Directory Server, the team designs the replication topology itself. 389 Directory Server provides asynchronous multi-supplier replication for fault tolerance and high write performance, and port389.org says database size is restricted only by disk space. That flexibility is useful, but every decision is yours: how many suppliers exist, which ones replicate to which, how each site is covered, and how failover is handled by your applications. You also own the consequences of a bad topology, such as writes that take time to converge across suppliers or a site that loses its only path to the directory. Confirm with the 389 Directory Server project which topology patterns it recommends for your number of sites before you commit to one.

FreeIPA takes most of that design work off your hands by publishing a layout. Its deployment recommendations advise at least two to three replicas in each datacenter, no more than four replication agreements per replica, and at least one replica per datacenter running PKI or DNS if you use those services. Dedicated servers without other applications are also recommended. The benefit is a tested starting point. The cost is that you must still fit your sites into that shape and keep it intact as you add or retire replicas. Ask your vendor or DeployOpen to show the replica map for your sites and the reasoning behind it, because the recommendations are guidance, not a substitute for an approved design.

Backups carry a different risk. FreeIPA provides ipa-backup and ipa-restore, with full or online data-only backups. Its backup documentation warns that the first server handles certificate renewal and CRL publication by default, so an outage of that server affects certificate lifecycle as well as logins. It also warns that restoring an outdated backup into an active replica topology can break replication. In a bare directory you control the backup tooling and the restore sequence, which means you carry that same risk without a published runbook. Either way, rehearse restores in an isolated environment, record which server holds the renewal role, and never restore a backup over a live topology without a documented procedure for re-establishing replication. The bare directory is acceptable when your team already runs LDAP at scale, needs custom topology or schema control, and has no requirement for Kerberos, an internal CA or host policy from the same product. FreeIPA is acceptable when you want one supported topology and one backup and renewal model across identity, certificates and DNS, and you can staff the operating model it implies. If neither condition fits, plan the operating roles before choosing.

Licensing and editions: both are community projects

FreeIPA is licensed under GPL-3.0-or-later, and the project itself has no paid edition. The software bundles 389 Directory Server, MIT Kerberos, the Dogtag certificate system and optional DNS and NTP services into one identity platform, so the license covers the whole stack you deploy. Under GPL terms you can run, modify and redistribute it, subject to the license conditions.

  • No project-level paid tier: Nothing in the project's own licensing introduces a feature-gated or subscription edition.
  • Distribution packaging: FreeIPA is packaged in Fedora, Debian and CentOS, and Red Hat Enterprise Linux ships it as Identity Management, a supported product with its own subscription terms.
  • Support scope differs by source: Community packages come with community support, while the Red Hat build is supported only within its RHEL subscription. The sibling comparison on FreeIPA and Red Hat Identity Management covers that difference in detail.
  • Services are separate spend: Installation, hardening, upgrades and support from a vendor or integrator are their own agreements, not license purchases.

Before budgeting, confirm with your distributor or vendor which support options apply to your distribution and version. Ask whether any fees, subscriptions or support terms are tied to the platform you choose.

What drives running cost for each option

Neither project charges a license fee. FreeIPA is GPL-3.0-or-later with no paid edition of its own, and 389 Directory Server is GPLv3, so the cost of either option is the people who design, install, operate and support it, the servers it runs on, and any support contract you buy from a vendor or partner. The biggest difference is what each option makes you build. A FreeIPA install delivers Kerberos, the Dogtag certificate authority, DNS and host policy in one package, while the bare directory leaves those pieces for your team to design and maintain. One-time costs cluster around design and proving the system works. For FreeIPA, that means choosing the replica layout, the DNS domain (which must not overlap with any Active Directory domain if you plan a trust), and the certificate authority model, then enrolling clients and testing what happens when a replica fails and when a backup is restored. For the bare directory, add the work of building Kerberos, certificate issuance, host policy and their integrations yourself, plus migration with openldap_to_ds if you are moving from OpenLDAP. Ask any partner to quote replica failure and restore testing as a named deliverable, not an assumed step.

Recurring costs are patching, upgrades, operating replicas and DNS servers, and on-call effort. FreeIPA's deployment recommendations advise at least two to three replicas in each datacenter, dedicated servers without other applications, at least one replica per datacenter running PKI or DNS if you use them, and at least two DNS servers in each client's resolv.conf. Each of those choices adds machines, monitoring and patch cycles, so the footprint is larger than a single directory service. The bare directory can run on fewer servers, but every custom Kerberos, certificate or policy component you build carries its own upgrade and testing burden, and FreeIPA's security fixes such as those in 4.13.4 must be applied by someone on your team either way. When requesting a quote, ask for the scope and written deliverables, who operates each component after handover (directory, Kerberos, CA, DNS, backups), which upgrades and security patches are included and for how long, and whether restore testing is part of the price. Confirm with the vendor or partner whether support for your platform version is covered by the subscription. The quote should state what the team must still do internally.

Moving between the bare directory and FreeIPA: what transfers and in what order

This sequence shows what moves from a standalone 389 Directory Server into FreeIPA, what FreeIPA regenerates on its own, and what has to be rebuilt by hand before clients and applications can cut over. Follow it in order, because the Kerberos realm, certificates and DNS depend on decisions made earlier in the sequence.

  1. Inventory schema, users, groups and access rules

    The directory owner lists every object class, attribute, user, group, ACI and sudo or host rule in the current directory, then marks which ones FreeIPA will own and which will be retired. Schema extensions that applications depend on need an owner and a test plan before anything moves. Done means a written inventory signed off by the directory owner and the application owners, with each sudo and HBAC-style rule recorded as a manual migration item, since FreeIPA's migration guidance does not carry those across automatically.

  2. Build the target FreeIPA topology first

    The platform team installs the new FreeIPA servers with the replica count and placement that the FreeIPA deployment recommendations describe, including at least one replica per datacenter running PKI or DNS if those services are used. The new realm is created with its own Kerberos realm and DNS domain, and the install is validated before any data moves. Done means replication between the new replicas is healthy and the team has confirmed the realm name and DNS domain with the owners of the existing environment.

  3. Migrate users and groups with ipa migrate-ds

    The team runs ipa migrate-ds against the source directory to import users and groups into FreeIPA. The tool excludes Kerberos attributes, which FreeIPA regenerates, so existing passwords and Kerberos keys do not carry over and users will need a reset or a controlled first-login process. Done means a count of imported users and groups matches the inventory, with exceptions logged, and a sample of accounts has been checked for group membership and attribute values.

  4. Rebuild Kerberos, certificates and DNS in the new install

    The Kerberos realm, the Dogtag certificate authority and the DNS zones are created in the new FreeIPA deployment rather than copied from the bare directory, since the bare directory did not provide those layers. The team sets the CA design, records who holds renewal and CRL duties, and confirms that clients will resolve the new DNS names. Done means a test host can obtain a Kerberos ticket, a test service certificate is issued and renewed, and DNS lookups return the expected records from every replica.

  5. Migrate sudo and HBAC rules by hand

    Sudo rules and host-based access control rules are recreated in FreeIPA from the inventory, using LDIF or the FreeIPA administrative tools, because the migration path does not transfer them. Each rule is tested on a non-production host with an account that should be allowed and one that should be denied. Done means every inventoried rule has a matching test result, and the owner of each rule has accepted the new version in writing.

  6. Move clients and applications

    Each client host is enrolled in FreeIPA with SSSD, and each application is repointed from the bare directory's LDAP endpoint to the FreeIPA endpoint, one application group at a time. Applications that bind with simple LDAP credentials need their bind DNs and search bases updated, and any service that needs Kerberos is tested against the new realm. Done means each application has passed a login and read test in the new environment, and rollback steps are documented for that group.

  7. Cut over, run in parallel, then decommission

    The team sets a cutover window agreed with the application owners, makes a fresh backup of the source directory and the new FreeIPA servers using FreeIPA's backup tooling, and moves write traffic to FreeIPA. The old directory stays read-only for a period agreed in advance so rollback remains possible. Decommissioning happens only after the owners sign off. Done means no application still reads from the old directory, the final backups are stored with the recovery steps, and the old servers are removed from DNS and monitoring.

  8. Plan the reverse move with the layers left behind

    Moving from FreeIPA back to a bare directory is possible for users and groups, but it leaves behind the Kerberos KDC, the Dogtag certificate authority, the DNS and NTP services and the host policy layer. A reverse plan lists which applications depend on those layers, how certificates would be reissued and how Kerberos service principals would be replaced. Done means the team can name each dependency that would need a new owner, and it is recorded in the same inventory used at the start of this sequence.

Where FreeIPA and 389 Directory Server projects run long

The schedule usually slips in the areas that sit outside the directory itself. DNS design is the first. A FreeIPA install ties client resolution, service discovery and, if used, the integrated DNS servers to the IPA domain, and the team has to settle that domain name before anything else is built. If a cross-forest trust with Active Directory is planned, the IPA domain must not overlap any DNS domain in the AD forest, so that check belongs in week one, not at trust setup. Client enrollment is the second source of delay. A mixed fleet of Linux hosts, appliances and systems with local customizations rarely enrolls in one pass, and each exception adds a test cycle. The third is certificate chain decisions made late. Whether the integrated Dogtag CA runs with a self-signed root, is signed by an external CA, or is replaced by certificates from an outside CA changes how services get certificates and how renewal is handled. Revisiting that choice after hosts are enrolled is expensive.

Application LDAP integration is where the bare 389 Directory Server option most often runs long. Each application expects its own bind accounts, group structure and schema attributes, and changes to the schema or access controls (ACIs) are made online through LDAP operations, which makes them easy to make and hard to roll back cleanly. Ask every application owner for a written list of required attributes and a dedicated test account before design starts. Replication and restore testing is the step most often skipped under pressure. FreeIPA's backup documentation warns that restoring an outdated backup into an active replica topology can break replication, so a restore drill against a copy of the topology is the check to schedule, not assume.

The work needs named owners on the client side: directory owners for the schema, groups and replication topology, DNS and PKI owners for the name space and certificate chain, and application owners who can provide test access and sign off on their LDAP behavior. DeployOpen works from a fixed-scope written agreement, so the scope, deliverables and timelines are agreed in writing before work starts, and a quote follows from that scope. Ask each owner group to confirm availability and decisions in that scope document, because the open decisions above are what move dates.

Questions buyers ask before choosing FreeIPA or 389 Directory Server

Is FreeIPA simply 389 Directory Server with extras?

Largely yes at the directory layer, but FreeIPA is more than a packaged LDAP server. FreeIPA uses 389 Directory Server as its multi-master LDAPv3 directory for users, groups, hosts and policies, then adds an MIT Kerberos KDC for single sign-on, the Dogtag certificate authority, SSSD on clients and optional ISC BIND DNS and NTP. The directory is the foundation; the extras are the parts that make it an identity platform for Linux and UNIX estates. Confirm which of these components you need, because each one adds configuration, replicas and patching work that a bare directory does not carry.

Can a team start with the bare directory and add Kerberos later?

Start with the bare directory only if your near-term needs are LDAP reads and writes for applications. Adding Kerberos, certificates and host policy later means building a second identity layer around the directory, not flipping a switch, because FreeIPA's Kerberos realm, CA and DNS are installed and configured as one system. Check how your chosen tooling would reconcile data and schema changes, and test the migration path on a copy of your directory before you commit. Ask the vendor or community maintainers which upgrade paths they support from a directory-only deployment.

How much more operating effort does FreeIPA need?

FreeIPA needs more operating effort because it runs more services. The FreeIPA deployment recommendations advise at least two to three replicas in each datacenter, no more than four replication agreements per replica, at least one replica per datacenter running PKI or DNS if used, and dedicated servers without other applications. A bare 389 Directory Server still needs replication design and backups, but it does not carry Kerberos key management or CA renewal duties. Effort rises with the number of sites, the number of hosts enrolled, and whether you run the CA and DNS. The FreeIPA backup documentation also warns that restoring an outdated backup into an active replica topology can break replication, so budget time for restore drills.

Is a paid support plan needed?

No paid support plan is required to run FreeIPA, because it is a GPL-3.0-or-later community project with no paid edition of its own. 389 Directory Server is also GPLv3 code. Whether you need a paid plan depends on your risk tolerance, your compliance obligations and how many people on your team can debug Kerberos, certificate or replication faults. Red Hat sells a supported build of Identity Management on RHEL, and FreeIPA is packaged in Fedora, Debian, CentOS and RHEL. Ask any provider which versions and distributions they will support, and what response times and escalation paths are included in writing.

What does the work need from our own staff?

Your staff must own the decisions and the operations, even when an outside team builds the system. Expect the work to need people who understand Linux administration, DNS, certificates, Kerberos ticket behavior and LDAP schema, plus someone who owns the on-call and patch cycle. For the bare directory, the skills centre on replication, ACIs and backup. For FreeIPA, add CA lifecycle, Kerberos principals and client enrollment through SSSD. Confirm internally who will approve certificate renewal, who runs the restore drills and who answers for the first server, which handles certificate renewal and CRL publication by default.

Can our own team implement this without an outside partner?

A capable Linux team can implement either option, but the decision depends on the skills and time you can commit. The bare directory can be stood up with dscreate, managed with dsctl, dsconf and dsidm, and watched through the Cockpit console, which is a smaller learning curve. FreeIPA adds the Kerberos realm, Dogtag and DNS, and the deployment choices made at install time are hard to unwind. If your team lacks that depth, a fixed-scope implementation partner can build, document and hand over the system, with scope, deliverables and timelines agreed in writing before work starts. DeployOpen plans, implements, integrates, hardens, backs up and documents self-hosted platforms in the client's own infrastructure, and quotes follow from the written scope.

How hard is it to switch later?

Switching is manageable for user and group data and harder for the parts that bind to Kerberos and certificates. FreeIPA provides migration from other LDAP servers with the ipa migrate-ds command, which excludes Kerberos attributes that FreeIPA regenerates, and sudo and HBAC rules need manual migration through LDIF. In the other direction, 389 Directory Server ships openldap_to_ds, which converts an OpenLDAP server on a best-effort basis. Moving off FreeIPA means re-keying clients, reissuing or re-trusting certificates and rebuilding host policy. Ask each vendor or maintainer to document the export path and the time your environment would need for a rehearsal.

How DeployOpen helps choose, implement or migrate between them

DeployOpen plans, implements and supports self-hosted open-source platforms inside your own infrastructure, so the choice between a bare 389 Directory Server and the full FreeIPA stack is settled against your environment rather than a generic template. We start from the services your Linux estate actually needs, then scope the work in writing before anything is built.

How we scope

  • Inventory which applications need LDAP only and which need Kerberos, host policy, sudo or certificates
  • Confirm replica count, sites and whether an Active Directory trust is required
  • Agree deliverables and timelines in a fixed-scope written statement before work starts

How we build

  • Deploy the chosen stack in your own cloud accounts, data centers or air-gapped network
  • Configure replication topology, backups with ipa-backup and access controls on the directory
  • Test authentication paths, failover between replicas and restore procedures before go-live

How we hand over

  • Document the architecture, replication agreements, certificate authority role and backup runbooks
  • Deliver configuration records and an operator guide written for your own administrators
  • Walk your team through routine tasks such as adding replicas, rotating credentials and restoring data

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer after handover
  • Plan upgrades for the directory and Kerberos components against the release notes in use
  • Prepare configuration and evidence for compliance assessments, while independent auditors issue any reports

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.