Descripción del flujo de autenticación Definición de un nombre de proveedor de desarrollador y asociación de dicho nombre a un grupo de identidades Implementación de un proveedor de identidad Actualización de la asignación de inicios de sesión (solo Android e iOS)Obtención de un token (lado del servidor)Conexión con una identidad social existente Compatibilidad con la transición entre proveedores

Identidades autenticadas por el desarrollador (grupos de identidades)

Amazon Cognito es compatible con las identidades autenticadas por el desarrollador y con la federación de identidades web mediante Configurar Facebook como un IdP de grupos de identidades, Configurar Google como un IdP de grupo de identidades, Configuración de Login with Amazon como un IdP de grupos de identidades y Configurar el inicio de sesión con Apple como un IdP de grupo de identidades. Con las identidades autenticadas por el desarrollador, puede registrar y autenticar a los usuarios mediante su propio proceso de autenticación existente y, al mismo tiempo, utilizar Amazon Cognito para sincronizar los datos de los usuarios y acceder a los recursos. AWS El uso de las identidades autenticadas por el desarrollador implica una interacción entre el dispositivo del usuario final, el backend para la autenticación y Amazon Cognito. Para obtener más información, consulte Descripción de la autenticación de Amazon Cognito, parte 2: Identidades autenticadas por desarrolladores, en el blog. AWS

Descripción del flujo de autenticación

La operación de la GetOpenIdTokenForDeveloperIdentityAPI puede iniciar la autenticación del desarrollador tanto para la autenticación básica como para la mejorada. Esta API autentica una solicitud con credenciales administrativas. El Logins mapa es el nombre de un desarrollador y proveedor de un grupo de identidades, login.mydevprovider junto con un identificador personalizado.

Ejemplo:


"Logins": {
        "login.mydevprovider": "my developer identifier"
    }

Autenticación mejorada

Llame a la operación de la GetCredentialsForIdentityAPI con un Logins mapa con el nombre cognito-identity.amazonaws.com y el valor del token desdeGetOpenIdTokenForDeveloperIdentity.

Ejemplo:


"Logins": {
        "cognito-identity.amazonaws.com": "eyJra12345EXAMPLE"
    }

GetCredentialsForIdentitycon identidades autenticadas por el desarrollador, devuelve credenciales temporales para el rol autenticado predeterminado del grupo de identidades.

Autenticación básica

Llama a la operación de la AssumeRoleWithWebIdentityAPI y solicita la RoleArn de cualquier rol de IAM que tenga definida una relación de confianza adecuada. Defina el valor del token del WebIdentityToken que se obtuvoGetOpenIdTokenForDeveloperIdentity.

Para obtener información sobre el flujo de autenticación de las identidades autenticadas por el desarrollador y en qué se diferencian de las identidades de los proveedores externos, consulte. Flujo de autenticación de grupos de identidades (identidades federadas)

Definición de un nombre de proveedor de desarrollador y asociación de dicho nombre a un grupo de identidades

Para utilizar las identidades autenticadas por el desarrollador, es preciso que el proveedor de desarrollador tenga un grupo de identidades asociado. Para ello, siga estos pasos:

Para agregar un proveedor de desarrolladores personalizado

Elija Grupos de identidades en la consola de Amazon Cognito. Seleccione un grupo de identidades.
Elija la pestaña Acceso de usuario.
Seleccione Agregar proveedor de identidades.
Elija un Proveedor de desarrolladores personalizado.
Ingrese un Nombre de proveedor de desarrolladores. No puede cambiar ni eliminar el proveedor de desarrolladores después de agregarlo.
Seleccione Guardar cambios.

Nota: una vez que se haya definido el nombre del proveedor, este no podrá modificarse.

Para obtener más indicaciones sobre cómo trabajar con la consola de Amazon Cognito, consulte Uso de la consola de Amazon Cognito.

Implementación de un proveedor de identidad

Android

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSAbstractCognitoIdentityProvider. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

El siguiente es un ejemplo básico de un proveedor de identidades.


public class DeveloperAuthenticationProvider extends AWSAbstractCognitoDeveloperIdentityProvider {

  private static final String developerProvider = "<Developer_provider_name>";

  public DeveloperAuthenticationProvider(String accountId, String identityPoolId, Regions region) {
    super(accountId, identityPoolId, region);
    // Initialize any other objects needed here.
  }

  // Return the developer provider name which you choose while setting up the
  // identity pool in the &COG; Console

  @Override
  public String getProviderName() {
    return developerProvider;
  }

  // Use the refresh method to communicate with your backend to get an
  // identityId and token.

  @Override
  public String refresh() {

    // Override the existing token
    setToken(null);

    // Get the identityId and token by making a call to your backend
    // (Call to your backend)

    // Call the update method with updated identityId and token to make sure
    // these are ready to be used from Credentials Provider.

    update(identityId, token);
    return token;

  }

  // If the app has a valid identityId return it, otherwise get a valid
  // identityId from your backend.

  @Override
  public String getIdentityId() {

    // Load the identityId from the cache
    identityId = cachedIdentityId;

    if (identityId == null) {
       // Call to your backend
    } else {
       return identityId;
    }

  }
}

Para utilizar este proveedor de identidad, tiene que pasarlo en CognitoCachingCredentialsProvider. A continuación se muestra un ejemplo:


DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", context, Regions.USEAST1);
CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);

iOS - Objective-C

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSCognitoCredentialsProviderHelper. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.


@implementation DeveloperAuthenticatedIdentityProvider
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */

- (AWSTask <NSString*> *) token {
    //Write code to call your backend:
    //Pass username/password to backend or some sort of token to authenticate user
    //If successful, from backend call getOpenIdTokenForDeveloperIdentity with logins map 
    //containing "your.provider.name":"enduser.username"
    //Return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = response.identityId;
    return [AWSTask taskWithResult:response.token];
}

@end

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:


DeveloperAuthenticatedIdentityProvider * devAuth = [[DeveloperAuthenticatedIdentityProvider alloc] initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION 
                                         identityPoolId:@"YOUR_IDENTITY_POOL_ID"
                                        useEnhancedFlow:YES
                                identityProviderManager:nil];
AWSCognitoCredentialsProvider *credentialsProvider = [[AWSCognitoCredentialsProvider alloc]
                                                          initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION
                                                          identityProvider:devAuth];

Si quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.


- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else{
        return [super logins];
    }
}

Si quiere dar soporte a las identidades autenticadas por el desarrollador y a los proveedores sociales, debe administrar quién es el proveedor actual en la implementación logins de AWSCognitoCredentialsProviderHelper.


- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

iOS - Swift


import AWSCore
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */
class DeveloperAuthenticatedIdentityProvider : AWSCognitoCredentialsProviderHelper {
    override func token() -> AWSTask<NSString> {
    //Write code to call your backend:
    //pass username/password to backend or some sort of token to authenticate user, if successful, 
    //from backend call getOpenIdTokenForDeveloperIdentity with logins map containing "your.provider.name":"enduser.username"
    //return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = resultFromAbove.identityId
    return AWSTask(result: resultFromAbove.token)
}

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:


let devAuth = DeveloperAuthenticatedIdentityProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityPoolId: "YOUR_IDENTITY_POOL_ID", useEnhancedFlow: true, identityProviderManager:nil)
let credentialsProvider = AWSCognitoCredentialsProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityProvider:devAuth)
let configuration = AWSServiceConfiguration(region: .YOUR_IDENTITY_POOL_REGION, credentialsProvider:credentialsProvider)
AWSServiceManager.default().defaultServiceConfiguration = configuration

Si quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.


override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else {
        return super.logins()
    }
}


override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

JavaScript

Una vez que obtenga un ID de identidad y un token de sesión del backend, deberá pasarlos al proveedor de AWS.CognitoIdentityCredentials. A continuación se muestra un ejemplo.


AWS.config.credentials = new AWS.CognitoIdentityCredentials({
   IdentityPoolId: 'IDENTITY_POOL_ID',
   IdentityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   Logins: {
      'cognito-identity.amazonaws.com': 'TOKEN_RETURNED_FROM_YOUR_PROVIDER'
   }
});

Unity

Para usar las identidades autenticadas por el desarrollador, debe ampliar CognitoAWSCredentials y anular el método RefreshIdentity para recuperar el ID y el token de identidad del usuario del backend y devolverlos. A continuación, se muestra un ejemplo sencillo de un proveedor de identidad que se pone en contacto con un hipotético backend en "example.com":


using UnityEngine;
using System.Collections;
using Amazon.CognitoIdentity;
using System.Collections.Generic;
using ThirdParty.Json.LitJson;
using System;
using System.Threading;

public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;

    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override IdentityState RefreshIdentity()
    {
        IdentityState state = null;
        ManualResetEvent waitLock = new ManualResetEvent(false);
        MainThreadDispatcher.ExecuteCoroutineOnMainThread(ContactProvider((s) =>
        {
            state = s;
            waitLock.Set();
        }));
        waitLock.WaitOne();
        return state;
    }

    IEnumerator ContactProvider(Action<IdentityState> callback)
    {
        WWW www = new WWW("http://example.com/?username="+login);
        yield return www;
        string response = www.text;

        JsonData json = JsonMapper.ToObject(response);

        //The backend has to send us back an Identity and a OpenID token
        string identityId = json["IdentityId"].ToString();
        string token = json["Token"].ToString();

        IdentityState state = new IdentityState(identityId, PROVIDER_NAME, token, false);
        callback(state);
    }
}

El código anterior utiliza un objeto distribuidor de subprocesos para llamar a una corutina. Si no dispone de una forma de hacerlo en su proyecto, puede utilizar el script siguiente en sus escenas:


using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class MainThreadDispatcher : MonoBehaviour
{
    static Queue<IEnumerator> _coroutineQueue = new Queue<IEnumerator>();
    static object _lock = new object();

    public void Update()
    {
        while (_coroutineQueue.Count > 0)
        {
            StartCoroutine(_coroutineQueue.Dequeue());
        }
    }

    public static void ExecuteCoroutineOnMainThread(IEnumerator coroutine)
    {
        lock (_lock) {
            _coroutineQueue.Enqueue(coroutine);
        }
    }
}

Xamarin

Para usar las identidades autenticadas por el desarrollador, debe ampliar CognitoAWSCredentials y anular el método RefreshIdentity para recuperar el ID y el token de identidad del usuario del backend y devolverlos. A continuación, se muestra un ejemplo sencillo de un proveedor de identidades que contacta con un hipotético backend en "example.com":


public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;
    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override async Task<IdentityState> RefreshIdentityAsync()
    {
        IdentityState state = null;
        //get your identity and set the state
        return state;
    }
}

Actualización de la asignación de inicios de sesión (solo Android e iOS)

Android

Después de autenticar correctamente al usuario con su propio sistema de autenticación, actualice la asignación de inicios de sesión con el nombre del proveedor de desarrollador y un identificador de usuario de desarrollador. Se trata de una cadena alfanumérica que identifica de forma exclusiva a un usuario en el sistema de autenticación. Asegúrese de llamar al método refresh después de actualizar la asignación de inicios de sesión, ya que identityId podría haber cambiado:


HashMap<String, String> loginsMap = new HashMap<String, String>();
loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier);

credentialsProvider.setLogins(loginsMap);
credentialsProvider.refresh();

iOS - Objective-C

El SDK para iOS solo llama al método logins para obtener la última asignación de inicios de sesión si no hay credenciales o estas han caducado. Si quiere obligar al SDK a obtener nuevas credenciales (por ejemplo, el usuario final ha pasado de no estar autenticado a estar autenticado y usted quiere credenciales sobre el usuario autenticado), llame a clearCredentials en su credentialsProvider.


[credentialsProvider clearCredentials];

iOS - Swift


credentialsProvider.clearCredentials()

Obtención de un token (lado del servidor)

Para obtener un token, llama. GetOpenIdTokenForDeveloperIdentity Esta API debe invocarse desde tu backend con las credenciales de AWS desarrollador. No debe invocarse desde el SDK de cliente. La API recibe el ID del grupo de identidades de Cognito, una asignación de inicios de sesión que contiene el nombre del proveedor de identidad como la clave y el identificador como el valor y, opcionalmente, un ID de identidad de Cognito (por ejemplo, está convirtiendo a un usuario sin autenticar en autenticado). El identificador puede ser el nombre de usuario del usuario, una dirección de correo electrónico o un valor numérico. La API responde a la llamada con un ID de Cognito único para el usuario y un token de OpenID Connect para el usuario final.

Tenga en cuenta los siguientes puntos sobre el token devuelto por GetOpenIdTokenForDeveloperIdentity:

Puede especificar una duración de vencimiento personalizada para el token para poder almacenarlo en la caché. Si no la proporciona, el token será válido durante 15 minutos.
La duración máxima del token que puede definir es de 24 horas.
Piense en las implicaciones para la seguridad que supone aumentar el token de duración. Si un atacante obtiene este token, puede cambiarlo por AWS credenciales para el usuario final durante el tiempo que dure el token.

En el siguiente fragmento Java, se muestra cómo inicializar un cliente de Amazon Cognito y recuperar un token para una identidad autenticada por el desarrollador.


// authenticate your end user as appropriate
// ....

// if authenticated, initialize a cognito client with your AWS developer credentials
AmazonCognitoIdentity identityClient = new AmazonCognitoIdentityClient(
  new BasicAWSCredentials("access_key_id", "secret_access_key")
);

// create a new request to retrieve the token for your end user
GetOpenIdTokenForDeveloperIdentityRequest request =
  new GetOpenIdTokenForDeveloperIdentityRequest();
request.setIdentityPoolId("YOUR_COGNITO_IDENTITY_POOL_ID");

request.setIdentityId("YOUR_COGNITO_IDENTITY_ID"); //optional, set this if your client has an
                                                   //identity ID that you want to link to this 
                                                   //developer account

// set up your logins map with the username of your end user
HashMap<String,String> logins = new HashMap<>();
logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
request.setLogins(logins);

// optionally set token duration (in seconds)
request.setTokenDuration(60 * 15l);
GetOpenIdTokenForDeveloperIdentityResult response =
  identityClient.getOpenIdTokenForDeveloperIdentity(request);

// obtain identity id and token to return to your client
String identityId = response.getIdentityId();
String token = response.getToken();

//code to return identity id and token to client
//...

Si sigue los pasos anteriores, debe tener la posibilidad de integrar las identidades autenticadas por el desarrollador en la aplicación. Si tiene algún problema o alguna pregunta, no dude en publicar en nuestros foros.

Toda vinculación de proveedores efectuada durante el uso de identidades autenticadas por el desarrollador se debe realizar desde el backend. Para conectar una identidad personalizada a la identidad social de un usuario (Login with Amazon, Sign in with Apple, Facebook o Google), añade el token del proveedor de identidad al mapa de inicios de sesión cuando llames GetOpenIdTokenForDeveloperIdentity. Para ello, cuando llame al backend desde el SDK de cliente para autenticar al usuario final, pase además el token de proveedor social del usuario final.

Por ejemplo, si está intentando vincular una identidad personalizada a Facebook, añada el token de Facebook, además del identificador del proveedor de identidad, a la asignación de inicios de sesión cuando llame a GetOpenIdTokenForDeveloperIdentity.


logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
logins.put("graph.facebook.com","END_USERS_FACEBOOK_ACCESSTOKEN");

Compatibilidad con la transición entre proveedores

Android

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. Por lo tanto, la aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para esto, tendrá que realizar algunos cambios en el proveedor de identidades personalizado.

El método refresh comprueba el mapa de inicios de sesión. Si el mapa no está vacío y tiene una clave con el nombre del proveedor de desarrolladores, llame al backend. De lo contrario, llama al getIdentityId método y devuelve null.


public String refresh() {

   setToken(null);

   // If the logins map is not empty make a call to your backend
   // to get the token and identityId
   if (getProviderName() != null &&
      !this.loginsMap.isEmpty() &&
      this.loginsMap.containsKey(getProviderName())) {

      /**
       * This is where you would call your backend
       **/

      // now set the returned identity id and token in the provider
      update(identityId, token);
      return token;

   } else {
      // Call getIdentityId method and return null
      this.getIdentityId();
      return null;
   }
}

Igualmente, el método getIdentityId tendrá dos flujos, en función del contenido de la asignación de inicios de sesión:


public String getIdentityId() {

   // Load the identityId from the cache
   identityId = cachedIdentityId;

   if (identityId == null) {

      // If the logins map is not empty make a call to your backend
      // to get the token and identityId

      if (getProviderName() != null && !this.loginsMap.isEmpty()
         && this.loginsMap.containsKey(getProviderName())) {

         /**
           * This is where you would call your backend
          **/

         // now set the returned identity id and token in the provider
         update(identityId, token);
         return token;

      } else {
         // Otherwise call &COG; using getIdentityId of super class
         return super.getIdentityId();
      }

   } else {
      return identityId;
   }

}

iOS - Objective-C

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.


- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a [credentialsProvider clearCredentials]; para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a [credentialsProvider clearKeychain];. Esto borrará las credenciales y la identidad y obligará al SDK a obtener otras nuevas.

iOS - Swift

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.


override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a credentialsProvider.clearCredentials() para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a credentialsProvider.clearKeychain(). Esto borrará las credenciales y la identidad y obligará al SDK a obtener otras nuevas.

Unity

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. La aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para ello, tendrá que realizar algunos cambios en el proveedor de identidad personalizado.

La forma recomendada de hacerlo en Unity es ampliar el proveedor de identidad desde AmazonCognitoEnhancedIdentityProvide y llamar al RefreshAsync método principal en lugar del tuyo propio en caso de que el usuario no esté autenticado con tu propio servidor. AbstractCognitoIdentityProvider Si el usuario está autenticado, puede utilizar el mismo flujo explicado anteriormente.

Xamarin

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de las demás identidades, la aplicación móvil interactúa directamente con Amazon Cognito, en lugar de contactar con el sistema de autenticación. La aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para esto, tendrá que realizar algunos cambios en el proveedor de identidades personalizado.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

SAMLproveedores de identidad

Cambio de identidades