This episode covers the commercial side of OpenVPN: managing a VPN through the OpenVPN Access Server web UI with LDAP, RADIUS, and SAML SSO integration, and CloudConnexa as a managed, zero-trust-based VPN service.

For 19 episodes you've worked with OpenVPN Community Edition — a daemon configured through text files. That's great for full control, but user management and monitoring require your own tooling. There's another path: commercial OpenVPN products that package all of that into a single bundle.
Episode 20 covers two such products. First, OpenVPN Access Server: a commercial server with a web UI, LDAP, RADIUS, and SAML SSO integration, plus centralized user management. Second, CloudConnexa: a managed, zero-trust-based VPN service that connects all resources without a server you manage yourself.
You'll compare when a self-hosted Community Edition is enough, when Access Server adds value, and when CloudConnexa saves time. There's no single answer — it all depends on scale and team resources.
Access Server is built on top of OpenVPN Community Edition, but adds a management layer: a web interface for managing the server, users, and configuration. Administrators no longer need to touch configuration files — everything goes through the UI.
Setup is significantly simplified. After installation, the administrator accesses the web UI on port 943, configures the VPN network, and creates users. Certificates and client configurations are generated automatically, removing the manual work previously done with Easy-RSA.
Access Server connects to existing authentication infrastructure. LDAP and RADIUS integration uses the same user database as other systems, and SAML SSO connects it to the corporate identity provider:
auth.saml.idp_metadata_url=https://idp.example.com/metadata
auth.saml.sp_entity_id=https://vpn.example.com:943auth.saml.idp_metadata_url and auth.saml.sp_entity_id register Access Server as a service provider in the IdP. After that, employees log in with the corporate SSO credentials and existing MFA, without a separate VPN account.
All users are managed from one place: creating accounts, granting group access, setting validity periods, and revoking access with one click. Compared to managing individual certificates in Community Edition, this is a huge leap in daily operational efficiency.
Access Server still provides a CLI for automation. The sacli tool lets scripts manage users and policy without opening a browser:
./sacli --user alice --newpass --key pass
./sacli --user alice --key prop_autologin --value true./sacli --user alice --newpass creates or resets a user's password from the terminal. For teams already used to the IaC patterns from episode 12, this CLI makes Access Server configuration expressible as code and verifiable through review.
Access Server generates client profiles that users simply download from the web UI. On the client side, the OpenVPN Connect app reads the profile and handles the connection. The combination of a web UI on the server and an app on the client makes configuration distribution — the theme of episode 9 — work without manual intervention.
CloudConnexa is a SaaS service from OpenVPN. You don't run a server yourself — OpenVPN manages the global infrastructure, while you define networks and resources through a portal. Clients are directed to the nearest server, and access policy is built on identity, not just IP addresses.
The concept is zero-trust: access is granted per user and per resource, not per network. Internal applications don't need to be exposed to the internet; only legitimate users can reach them.
To reach local networks — an office or private cloud — CloudConnexa uses a Connector: a daemon installed inside that network that opens a secure outbound path to the CloudConnexa network:
sudo ./connector -connector-token=CONNECTOR_TOKEN./connector -connector-token=CONNECTOR_TOKEN registers your network to the portal. Once connected, resources in that network are accessible to allowed users without opening any public port on the network side.
Because the infrastructure is global, clients from different locations connect to the nearest entry point. Latency is lower than forcing all clients toward a single server. This is value that's hard to replicate with a single standalone server in one region.
Through the portal, you define routes — which subnets are reachable via the Connector — and per-user policy. Example: the engineering team only sees the development subnet, the finance team only the ERP subnet. This is the network policy from episode 16 realized at a centralized, provider-managed level.
In CloudConnexa, certificate and key management is handled automatically by the provider. You don't need to think about the PKI rotation discussed in episode 21 — enrolled devices are provisioned and revoked through the portal. This removes most of the administrative VPN workload.
The most flexible and cheapest — free under license, only server costs. Suitable when the team has the expertise and non-standard requirements. Trade-off: all management and monitoring is your responsibility, exactly as learned in episodes 12 and 19.
Gives management convenience while keeping data in your own infrastructure. Suitable for organizations that need SSO, centralized user management, and a web UI, but have data policies prohibiting third-party infrastructure.
Saves the most operational time. Suitable for small teams without a dedicated network team, or organizations needing fast deployment and global reach. Trade-off: data and control are largely in the provider's hands.
Community Edition has the lowest license cost but the highest operational hours — all the maintenance from episode 21 is on you. Access Server adds license cost but reduces daily admin work. CloudConnexa replaces license cost with a per-user subscription, and nearly eliminates operational work on your side.
Key takeaways:
In the next episode, episode 21, we will discuss production-ready deployment and maintenance — a PKI rotation and certificate renewal checklist with ACME, backup and disaster recovery strategies, safe upgrade patterns, and deployments with bare-metal, VM, Docker, Kubernetes, and IaC. After this episode, your VPN is ready for long-term management.