Connexion aux bases de données Amazon Neptune à l'aide d'IAM avec Gkremlin Java - Amazon Neptune
Authentification IAM entre comptes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Connexion aux bases de données Amazon Neptune à l'aide d'IAM avec Gkremlin Java

Voici un exemple de connexion à Neptune à l'aide de l'API Java Gkremlin avec signature Sig4 (cela suppose des connaissances générales sur l'utilisation de Maven). Cet exemple utilise la bibliothèque Amazon Neptune SigV4 Signer pour faciliter la signature des demandes. Définissez d'abord les dépendances dans le cadre du fichier pom.xml :

Note

Les exemples suivants utilisentrequestInterceptor(), qui a été introduit dans la version TinkerPop 3.6.6. Si vous utilisez une TinkerPop version antérieure à 3.6.6 (mais 3.5.5 ou supérieure), utilisez handshakeInterceptor() plutôt que requestInterceptor() dans les exemples de code ci-dessous.

<dependency>
  <groupId>com.amazonaws</groupId>
  <artifactId>amazon-neptune-sigv4-signer</artifactId>
  <version>3.1.0</version>
</dependency>

Amazon Neptune SigV4 Signer prend en charge les versions 1.x et 2.x du SDK Java. AWS Les exemples suivants utilisent 2.x, où DefaultCredentialsProvider est une software.amazon.awssdk.auth.credentials.AwsCredentialsProvider instance. Si vous passez de la version 1.x à la version 2.x, consultez les modifications apportées au fournisseur d'informations d'identification dans la documentation du AWS SDK for Java 2.x. 

import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer;
import com.amazonaws.neptune.auth.NeptuneSigV4SignerException;

 ...

System.setProperty("aws.accessKeyId","your-access-key");
System.setProperty("aws.secretKey","your-secret-key");

 ...

Cluster cluster = Cluster.build((your cluster))
                 .enableSsl(true)
                 .requestInterceptor( r ->
                  {
                    try {
                      NeptuneNettyHttpSigV4Signer sigV4Signer =
                        new NeptuneNettyHttpSigV4Signer("(your region)", DefaultCredentialsProvider.create());
                      sigV4Signer.signRequest(r);
                    } catch (NeptuneSigV4SignerException e) {
                      throw new RuntimeException("Exception occurred while signing the request", e);
                    }
                    return r;
                  }
                 ).create();
try {
  Client client = cluster.connect();
  client.submit("g.V().has('code','IAD')").all().get();
} catch (Exception e) {
  throw new RuntimeException("Exception occurred while connecting to cluster", e);
}

Authentification IAM entre comptes

Amazon Neptune prend en charge l'authentification IAM entre comptes grâce à l'utilisation de l'hypothèse de rôles, parfois appelée chaînage de rôles. Pour donner accès à un cluster Neptune à partir d'une application hébergée sur un autre AWS compte, procédez comme suit :

  • Créez un nouvel utilisateur ou rôle IAM dans le AWS compte d'application, avec une politique de confiance qui permet à l'utilisateur ou au rôle d'assumer un autre rôle IAM. Attribuez ce rôle au calcul hébergeant l'application (instance EC2, fonction Lambda, tâche ECS, etc.).

    JSON
    
{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Sid": "assumeRolePolicy",
      "Effect": "Allow",
      "Action": "sts:AssumeRole",
      "Resource": "arn:aws:iam::111122223333:role/role-name"
    }
  ]
}

  • Créez un nouveau rôle IAM dans le compte de base de données Neptune qui permet d'accéder à la AWS base de données Neptune et d'assumer un rôle à partir du compte d'application IAM utilisateur/rôle. Utilisez une politique de confiance basée sur :

    JSON
    {
    "Version":"2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": [
                    "(ARN of application account IAM user or role)"
                ]
            },
            "Action": "sts:AssumeRole",
            "Condition": {}
        }
    ]
}

  • Utilisez l'exemple de code suivant pour savoir comment utiliser ces deux rôles pour autoriser l'application à accéder à Neptune. Dans cet exemple, le rôle du compte d'application sera assumé via le DefaultCredentialProviderChainlors de la création duSTSclient. STSclientIl est ensuite utilisé via le STSAssumeRoleSessionCredentialsProvider pour assumer le rôle hébergé dans le compte de base AWS de données Neptune. 

    public static void main( String[] args )
  {

    /* 
     * Establish an STS client from the application account.
     */
    AWSSecurityTokenService client = AWSSecurityTokenServiceClientBuilder
        .standard()
        .build();

    /*
     * Define the role ARN that you will be assuming in the database account where the Neptune cluster resides.
     */
    String roleArnToAssume = "arn:aws:iam::012345678901:role/CrossAccountNeptuneRole";
    String crossAccountSessionName = "cross-account-session-" + UUID.randomUUID();

    /*
     * Change the Credentials Provider in the SigV4 Signer to use the STSAssumeRole Provider and provide it
     * with both the role to be assumed, the original STS client, and a session name (which can be
     * arbitrary.)
     */
    Cluster cluster = Cluster.build()
                 .addContactPoint("neptune-cluster.us-west-2.neptune.amazonaws.com")
                 .enableSsl(true)
                 .port(8182)
                 .requestInterceptor( r ->
                  {
                    try {
                      NeptuneNettyHttpSigV4Signer sigV4Signer =
                        // new NeptuneNettyHttpSigV4Signer("us-west-2", DefaultCredentialsProvider.create());
                        new NeptuneNettyHttpSigV4Signer(
                                "us-west-2",  
                                 new STSAssumeRoleSessionCredentialsProvider
                                    .Builder(roleArnToAssume, crossAccountSessionName)
                                        .withStsClient(client)
                                        .build());
                      sigV4Signer.signRequest(r);
                    } catch (NeptuneSigV4SignerException e) {
                      throw new RuntimeException("Exception occurred while signing the request", e);
                    }
                    return r;
                  }
                 ).create();

    GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));

    /* whatever application code is necessary */

    cluster.close();
  }