Edge for Private Cloud Version 4.18.01
Mit der externen Rollenzuordnung können Sie Ihre eigenen Gruppen oder Rollen rollenbasierten Zugriffssteuerungsrollen (Role-Based Access Control, RBAC) und Gruppen zuordnen, die in Apigee Edge erstellt wurden. Dieses Feature ist nur für Edge Private Cloud verfügbar.
Neuerungen
Der externe Rollenzuordnungsdienst für Edge for Private Cloud-Releases vor 4.18.01 wurde verworfen. Version 4.18.01 der externen Rollenzuordnung ist eine aktualisierte Version, in der Fehler behoben und neue Funktionen hinzugefügt wurden:
- Das Problem, dass bei der Authentifizierung bei Nutzern, die Zugriff haben sollten, von der Authentifizierung 403 unzulässige Antworten empfangen wurden, wurde behoben.
- Der Header X-Apigee-Current-User wird jetzt in der externen Rollenzuordnung unterstützt. Nutzer mit dem entsprechenden Zugriff (sysadmin) können jetzt die einem anderen Nutzer zugewiesenen Rollen ansehen.
Voraussetzungen
- Sie müssen ein Apigee Private Cloud-Systemadministrator mit globalen Anmeldedaten für den Systemadministrator sein, um diese Konfiguration durchzuführen.
-
Sie müssen das Stammverzeichnis Ihrer Apigee Edge Private Cloud-Installation kennen. Das Standardstammverzeichnis ist /opt.
Detailliertes Beispiel für die Einrichtung
In diesem Artikel in den Apigee-Community-Foren finden Sie ein Schritt-für-Schritt-Beispiel für das Einrichten der externen Rollenzuordnung.
Standardkonfiguration
Die Zuordnung externer Rollen ist standardmäßig deaktiviert.
Externe Rollenzuordnung aktivieren
- Bevor Sie die folgende Konfiguration ausführen können, müssen Sie eine Java-Klasse erstellen, in der die Schnittstelle ExternalRoleMapperServiceV2 implementiert ist, und Ihre Implementierung in den Klassenpfad von Management Server aufnehmen:
/opt/apigee/edge-management-server/lib/thirdparty/
Weitere Informationen zu dieser Implementierung finden Sie im Abschnitt Informationen zur Beispielimplementierung für ExternalRoleMapperImpl weiter unten in diesem Dokument. - Melden Sie sich bei Ihrem Apigee Edge-Verwaltungsserver an und beenden Sie den Verwaltungsserverprozess:
> /opt/apigee/apigee-service/bin/apigee-service Edge-management-server stop - Öffnen Sie /opt/apigee/customer/application/management-server.properties in einem Texteditor. Wenn diese Datei nicht vorhanden ist, erstellen Sie sie.
- Bearbeiten Sie die Eigenschaftendatei und nehmen Sie folgende Einstellungen vor:
# Der für die Authentifizierung zu verwendende Nutzerspeicher.
# „externalized.authentication“ für den LDAP-Nutzerspeicher verwenden.
# Beachten Sie, dass wir für die Autorisierung weiterhin LDAP verwenden.
# Weitere Informationen zum Aktivieren der externen Authentifizierung finden Sie unter Externe Authentifizierung aktivieren.
conf_security_authentication.user.store=externalized.authentication
#Aktivieren Sie die externe Autorisierungs-Role Mapper.
conf_security_externalized.authentication.role.mapper.enabled=true conf_security_externalized.authentication.role.mapper.implementation.class=com.customer.authorization.impl.ExternalRoleMapperImpl
Wichtig: Die Implementierungsklasse und der Paketname, auf die in der obigen Konfiguration verwiesen wird, sind nur der Name, den Sie implementieren können (ExternalRoleMapperImpl). Weitere Informationen zum Implementieren dieser Klasse finden Sie unten im Abschnitt Informationen zur Beispielimplementierung für ExternalRoleMapperImpl. Dies ist eine Klasse, die Sie implementieren müssen, um Ihre eigenen Gruppen widerzuspiegeln. - Speichern Sie die Datei management-server.properties.
- Achten Sie darauf, dass management-server.properties dem Apigee-Benutzer gehört:?
> apigee apigee:apigee /opt/apigee/customer/application/management-server.properties - Starten Sie den Verwaltungsserver:
> /opt/apigee/apigee-service/bin/apigee-service-Edge-management-server start
Externe Autorisierung deaktivieren
So deaktivieren Sie die externe Autorisierung:
- Öffnen Sie /opt/apigee/customer/application/management-server.properties in einem Texteditor. Wenn die Datei nicht vorhanden ist, erstellen Sie sie.
- Ändern Sie den Authentifizierungsnutzerspeicher in ldap:
conf_security_authentication.user.store=ldap - Legen Sie dieses Attribut auf „false“ fest:
conf_security_externalized.authentication.role.mapper.enabled=false - Starten Sie den Verwaltungsserver neu:
> /opt/apigee/apigee-service/bin/apigee-service-Edge-management-server start
Beispielimplementierung „ExternalRoleMapperImpl“
Beachten Sie in der Konfigurationsdatei „security.properties“, die zuvor unter Zuordnung externer Rollen aktivieren beschrieben wurde, die folgende Zeile:
externalized.authentication.role.mapper.implementation.class=com.customer.authorization.impl.ExternalRoleMapperImpl
Diese Klasse implementiert die Schnittstelle ExternalRoleMapperServiceV2 und ist erforderlich. Sie müssen eine eigene Implementierung dieser Klasse erstellen, die Ihre jeweiligen Gruppen widerspiegelt. Platzieren Sie anschließend die kompilierte Klasse in einer JAR-Datei und diese im Klassenpfad des Management Servers unter:
/opt/apigee/edge-management-server/lib/thirdparty/
Sie können der Klasse und dem Paket einen beliebigen Namen geben, solange ExternalRoleMapperServiceV2 implementiert wird, in Ihrem Klassenpfad zugegriffen werden kann und in der Konfigurationsdatei management-server.properties korrekt verwiesen wird.
Nachfolgend finden Sie eine gut kommentierte Beispielimplementierung einer ExternalRoleMapperImpl-Klasse.
package com.customer.authorization.impl;
import com.apigee.authentication.*;
import com.apigee.authorization.namespace.OrganizationNamespace;
import com.apigee.authorization.namespace.SystemNamespace;
import java.util.Collection;
import java.util.HashSet;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
/** *
* Sample Implementation constructed with dummy roles with expected namespaces.
*/
public class ExternalRoleMapperImpl
implements ExternalRoleMapperServiceV2 {
InitialDirContext dirContext = null;
@Override
public void start(ConfigBean arg0) throws ConnectionException {
try {
// Customer Specific Implementation will override the
// ImplementDirContextCreationLogicForSysAdmin method implementation.
// Create InitialDirContext based on the system admin user credentials.
dirContext = ImplementDirContextCreationLogicForSysAdmin();
} catch (NamingException e) {
// TODO Auto-generated catch block
throw new ConnectionException(e);
}
}
@Override
public void stop() throws Exception {
}
/**
* This method should be replaced with customer's implementation
* For given roleName under expectedNamespace, return all users that belongs to this role
* @param roleName
* @param expectedNamespace
* @return All users that belongs to this role. For each user, please return the username/email that is stored in Apigee LDAP
* @throws ExternalRoleMappingException
*/
@Override
public Collection<String> getUsersForRole(String roleName, NameSpace expectedNamespace) throws ExternalRoleMappingException {
Collection<String> users = new HashSet<>();
if (expectedNamespace instanceof SystemNamespace) {
// If requesting all users with sysadmin role
if (roleName.equalsIgnoreCase("sysadmin")) {
// Add sysadmin's email to results
users.add("sysadmin@wacapps.net");
}
} else {
String orgName = ((OrganizationNamespace) expectedNamespace).getOrganization();
// If requesting all users of engRole in Apigee LDAP
if (roleName.equalsIgnoreCase("engRole")) {
// Get all users in corresponding groups in customer's LDAP. In this case looking for 'engGroup';
SearchControls controls = new SearchControls();
controls.setSearchScope(1);
try {
NamingEnumeration<SearchResult> res = dirContext.search("ou=groups,dc=corp,dc=wacapps,dc=net",
"cn=engGroup", new Object[]{"",""}, controls);
while (res.hasMoreElements()) {
SearchResult sr = res.nextElement();
// Add all users into return
users.addAll(sr.getAttributes().get("users").getAll());
}
} catch (NamingException e) {
// Customer needs to handle the exception here
}
}
}
return users;
}
/**
*
* This method would be implemented by the customer and would be invoked
* while including using X-Apigee-Current-User header in request.
*
* X-Apigee-Current-User allows the customer to login as another user
*
* Below is the basic example.
*
* If User has sysadmin role then it's expected to set SystemNameSpace
* along with the expected NameSpace. Otherwise role's expectedNameSpace
* to be set for the NameSpacedRole.
*
* Collection<NameSpacedRole> results = new HashSet<NameSpacedRole>();
*
* NameSpacedRole sysNameSpace = new NameSpacedRole("sysadmin",
* SystemNamespace.get());
*
* String orgName =
* ((OrganizationNamespace) expectedNameSpace).getOrganization();
*
* NameSpacedRole orgNameSpace = new NameSpacedRole ("orgadmin",
* expectedNameSpace);
*
* results.add(sysNameSpace);
*
* results.add(orgNameSpace);
*
*
* @param username UserA's username
* @param password UserA's password
* @param requestedUsername UserB's username. Allow UserA to request UserB's userroles with
* UserA's credentials when requesting UserB as X-Apigee-Current-User
* @param expectedNamespace
* @return
* @throws ExternalRoleMappingException
*/
@Override
public Collection<NameSpacedRole> getUserRoles(String username, String password, String requestedUsername, NameSpace expectedNamespace) throws ExternalRoleMappingException {
/************************************************************/
/******************** Authenticate UserA ********************/
/************************************************************/
// Customer Specific Implementation will override the
// ImplementDnameLookupLogic method implementation.
// obtain dnName for given username.
String dnName = ImplementDnNameLookupLogic(username);
// Obtain dnName for given requestedUsername.
String requestedDnName = ImplementDnNameLookupLogic(requestedUsername);
if (dnName == null || requestedDnName == null) {
System.out.println("Error ");
}
DirContext dirContext = null;
try {
// Customer Specific Implementation will override the
// ImplementDirectoryContextCreationLogic method implementation
// Create a directory context with dnName or requestedDnName and password
dirContext = ImplementDirectoryContextCreationLogic();
/************************************************/
/*** Map internal groups to apigee-edge roles ***/
/************************************************/
return apigeeEdgeRoleMapper(dirContext, requestedDnName, expectedNamespace);
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("Error in authenticating User: {}" + new Object[] { username });
} finally {
// Customer implementation to close
// ActiveDirectory/LDAP context.
}
return null;
}
/**
*
* This method would be implemented by the customer and would be invoked
* wihle using username and password for authentication and without the
* X-Apigee-Current-User header
*
* The customer can reuse implementations in
* getUserRoles(String username, String password, String requestedUsername, NameSpace expectedNamespace)
* by
* return getUserRoles(username, password, username, expectedNamespace)
* in implementations.
*
* or the customer can provide new implementations as shown below.
*/
@Override
public Collection<NameSpacedRole> getUserRoles(String username, String password, NameSpace expectedNamespace) throws ExternalRoleMappingException {
/*************************************************************/
/****************** Authenticate Given User ******************/
/*************************************************************/
// Customer Specific Implementation will override the
// ImplementDnameLookupLogic implementation.
// Obtain dnName for given username or email address.
String dnName = ImplementDnNameLookupLogic(username);
if (dnName == null) {
System.out.println("Error ");
}
DirContext dirContext = null;
try {
// Create a directory context with username or dnName and password
dirContext = ImplementDirectoryContextCreationLogic();
/************************************************/
/*** Map internal groups to apigee-edge roles ***/
/************************************************/
return apigeeEdgeRoleMapper(dirContext, dnName, expectedNamespace);
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("Error in authenticating User: {}" + new Object[] { username });
} finally {
// Customer implementation to close
// ActiveDirectory/LDAP context.
}
return null;
}
/**
*
* This method would be implemented by the customer and would be invoked
* while using security token or access token as authentication credentials.
*
*/
@Override
public Collection<NameSpacedRole> getUserRoles(String username, NameSpace expectedNamespace) throws ExternalRoleMappingException {
/*************************************************************/
/****************** Authenticate Given User ******************/
/*************************************************************/
// Customer Specific Implementation will override the
// ImplementDnameLookupLogic implementation.
// Obtain dnName for given username or email address.
String dnName = ImplementDnNameLookupLogic(username);
if (dnName == null) {
System.out.println("Error ");
}
DirContext dirContext = null;
try {
// Create a directory context with username or dnName and password
dirContext = ImplementDirectoryContextCreationLogic();
/************************************************/
/*** Map internal groups to apigee-edge roles ***/
/************************************************/
return apigeeEdgeRoleMapper(dirContext, dnName, expectedNamespace);
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("Error in authenticating User: {}" + new Object[] { username });
} finally {
// Customer implementation to close
// ActiveDirectory/LDAP context.
}
return null;
}
/**
* This method should be replaced with Customer Specific Implementations
*
* Provided as a sample Implementation of mapping user groups to apigee-edge roles
*/
private Collection<NameSpacedRole> apigeeEdgeRoleMapper(DirContext dirContext, String dnName, NameSpace expectedNamespace) throws Exception {
Collection<NameSpacedRole> results = new HashSet<NameSpacedRole>();
/****************************************************/
/************ Fetch internal groups *****************/
/****************************************************/
String groupDN = "OU=Groups,DC=corp,DC=wacapps,DC=net";
String userFilter = "(user=userDnName)";
SearchControls controls = new SearchControls();
controls.setSearchScope(SearchControls.ONELEVEL_SCOPE);
// Looking for all groups the user belongs to in customer's LDAP
NamingEnumeration<SearchResult> groups = dirContext.search(groupDN,userFilter.replace("userDnName", dnName), new Object[] { "", "" }, controls);
if (groups.hasMoreElements()) {
while (groups.hasMoreElements()) {
SearchResult searchResult = groups.nextElement();
Attributes attributes = searchResult.getAttributes();
String groupName = attributes.get("name").get().toString();
/************************************************/
/*** Map internal groups to apigee-edge roles ***/
/************************************************/
if (groupName.equals("BusDev")) {
results.add(new NameSpacedRole("businessAdmin",SystemNamespace.get()));
} else if (groupName.equals("Engineering")) {
if (expectedNamespace instanceof OrganizationNamespace) {
String orgName = ((OrganizationNamespace) expectedNamespace).getOrganization();
results.add(new NameSpacedRole("orgadmin", new OrganizationNamespace(orgName)));
}
} else if (groupName.equals("Marketing")) {
results.add(new NameSpacedRole("marketAdmin",SystemNamespace.get()));
} else {
results.add(new NameSpacedRole("readOnly",SystemNamespace.get()));
}
}
} else {
// In case of no group found or exception found we throw empty roles.
System.out.println(" !!!!! NO GROUPS FOUND !!!!!");
}
return results;
}
/**
* The customer need to replace with own implementations for getting dnName for given user
*/
private String ImplementDnNameLookupLogic(String username) {
// Connect to the customer's own LDAP to fetch user dnName
return customerLDAP.getDnName(username);
}
/**
* The customer need to replace with own implementations for creating DirContext
*/
private DirContext ImplementDirectoryContextCreationLogic() {
// Connect to the customer's own LDAP to create DirContext for given user
return customerLDAP.createLdapContextUsingCredentials();
}
}