Ta strona została przetłumaczona przez Cloud Translation API.

Mapowanie ról zewnętrznych

Edge for Private Cloud w wersji 4.18.01

Zewnętrzne mapowanie ról pozwala mapować własne grupy lub role na kontrolę dostępu opartą na rolach Role i grupy (RBAC) utworzone w Apigee Edge. Ta funkcja jest dostępna tylko w Edge Private Google Cloud.

Co nowego

Usługa mapowania ról zewnętrznych dla Edge for Private Cloud w wersji wcześniejszej niż 4.18.01 ma została wycofana. Wersja 4.18.01 zewnętrznego mapowania ról to zaktualizowana wersja z poprawionymi błędami i nowych funkcji:

Rozwiązaliśmy problem, który powodował, że otrzymywano odpowiedzi zabronione 403 dotyczące uwierzytelniania, gdy uwierzytelniać się z użytkownikami, którzy powinni mieć dostęp.
X-Apigee-Current-User nagłówek jest teraz obsługiwany w mapowaniu ról zewnętrznych. Użytkownicy z odpowiednim dostępem (sysadmin) mogą teraz wyświetlić role przypisane innemu użytkownikowi.

Wymagania wstępne

Musisz być administratorem systemu Apigee Private Cloud z globalnym administratorem systemu dane logowania, aby przeprowadzić tę konfigurację.
Musisz znać katalog główny instalacji Apigee Edge Private Cloud. domyślny katalog główny to /opt.

Przykład konfiguracji krok po kroku

Zobacz ten artykuł na forach społeczności Apigee znajdziesz szczegółowy przykład konfiguracji zewnętrznej. mapowania ról.

Konfiguracja domyślna

Mapowanie ról zewnętrznych jest domyślnie wyłączone.

Włączanie mapowania ról zewnętrznych

Przed ukończeniem poniższej konfiguracji musisz utworzyć klasę Java, która: implementuje interfejs ExternalRoleMapperServiceV2 i umieszcza Twoją implementację w funkcji Ścieżka klasy serwera zarządzania:

/opt/apigee/edge-management-server/lib/thirdparty/

Szczegółowe informacje na temat tej implementacji znajdziesz w sekcji Informacje o obiekcie ExternalRoleMapperImpl przykładową implementację w dalszej części tego dokumentu.
Zaloguj się na serwer zarządzania Apigee Edge i zatrzymaj serwer zarządzania proces:
> /opt/apigee/apigee-service/bin/apigee-service zatrzymanie serwera Edge-management-server
Otwórz stronę /opt/apigee/customer/application/management-server.properties w edytorze tekstu. Jeśli ten plik nie istnieje, utwórz go.
W pliku właściwości wprowadź następujące ustawienia:
# Magazyn użytkownika, który ma być używany w przypadku uwierzytelnianie.
# Użyj polecenia „externalized.authentication” dla magazynu użytkowników LDAP.
# Pamiętaj, że na potrzeby autoryzacji nadal używamy protokołu LDAP.
# Zobacz więcej informacji na temat włączania uwierzytelniania zewnętrznego. na temat włączania uwierzytelniania zewnętrznego.
conf_security_authentication.user.store=externalized.authentication

#Włącz zewnętrzne narzędzie do mapowania roli autoryzacji.
conf_security_externalized.authentication.role.mapper.enabled=true conf_security_externalized.authentication.role.mapper.implementation.class=com.customer.authorization.impl.ExternalRoleMapperImpl

Ważne: klasa implementacji i nazwa pakietu, do których odwołuje się powyższa konfiguracja (ExternalRoleMapperImpl) to tylko przykłady – to klasa, którą należy zaimplementować, możesz nazwać zajęcia i opakować je dowolnie, Szczegółowe informacje na temat implementacji tej znajdziesz w artykule Informacje o ExternalRoleMapperImpl przykładową implementację poniżej. Na tych zajęciach które musisz wdrożyć, aby odzwierciedlić Twoje własne grupy.
Zapisz plik management-server.properties.
Upewnij się, że domena management-server.properties należy do: użytkownik Apigee:?
> chown apigee:apigee /opt/apigee/customer/application/management-server.properties
Uruchom serwer zarządzania:
> /opt/apigee/apigee-service/bin/apigee-service uruchomienie serwera zarządzania brzegiem sieci

Wyłączanie autoryzacji zewnętrznej

Aby wyłączyć autoryzację zewnętrzną:

Otwórz stronę /opt/apigee/customer/application/management-server.properties w edytorze tekstu. Jeśli plik nie istnieje, utwórz go.
Zmień magazyn użytkowników uwierzytelniania na ldap:
conf_security_authentication.user.store=ldap
Ustaw tę właściwość na wartość false:
conf_security_externalized.authentication.role.mapper.enabled=false
Ponownie uruchom serwer zarządzania:
> /opt/apigee/apigee-service/bin/apigee-service uruchomienie serwera zarządzania brzegiem sieci

Informacje o obiekcie ExternalRoleMapperImpl przykładowa implementacja

W pliku konfiguracji security.properties opisanym wcześniej w sekcji Włączanie mapowania ról zewnętrznych zwróć uwagę na ten wiersz:

externalized.authentication.role.mapper.implementation.class=com.customer.authorization.impl.ExternalRoleMapperImpl

Ta klasa implementuje interfejs ExternalRoleMapperServiceV2 i jest wymagana. Czynności, które musisz wykonać utwórz własną implementację tych zajęć, która odzwierciedla Twoje grupy. Gdy skończysz, umieść skompilowaną klasę w pliku JAR i umieść ją w ścieżce klasy serwera zarządzania:

/opt/apigee/edge-management-server/lib/thirdparty/

Ostrzeżenie: aby skompilować tę klasę, musisz odwołać się do tego pliku JAR dołączonego do Brzeg:

/opt/apigee/edge-management-server/lib/infra/libraries/authentication-1.0.0.jar

Możesz nazwać klasę i pakiet dowolnie, jeśli tylko zaimplementowano Obiekt ExternalRoleMapperServiceV2 jest dostępny w ścieżce klasy i przywołany poprawnie w .

Poniżej znajdziesz dokładnie skomentowaną przykładową implementację klasy ExternalRoleMapperImpl.

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();
   }

}