Utilisation d'AWS IAM dans Go : un guide complet

AWS (Amazon Web Services), en tant que leader du secteur du cloud computing, fournit des services de cloud computing pratiques et puissants, permettant aux entreprises de créer et de gérer facilement leur propre infrastructure informatique et d'obtenir une meilleure évolutivité, une meilleure flexibilité et un faible coût. IAM (Identity and Access Management) est l'un des services importants d'AWS. Il est chargé de gérer l'identité et les droits d'accès des utilisateurs (y compris les personnes, les applications, les services, etc.) et d'assurer la sécurité et la confidentialité des ressources AWS. Dans cet article, nous présenterons comment utiliser AWS IAM en langage Go et fournirons des méthodes de mise en œuvre détaillées et des exemples de code.

1. Créer des utilisateurs et des rôles IAM dans AWS

Tout d'abord, nous devons créer des utilisateurs et des rôles IAM dans AWS. Un utilisateur IAM est l'identité des ressources AWS et un rôle est l'autorisation d'accès à ces ressources. Nous pouvons créer et gérer ces identités et autorisations à l'aide de la console AWS ou de l'AWS CLI. Voici les étapes pour créer un utilisateur et un rôle IAM à l'aide de la console AWS :

1. Connectez-vous à la console AWS et accédez à la console IAM.
2. Cliquez sur « Utilisateurs » dans la barre de navigation de gauche, puis cliquez sur « Ajouter un utilisateur ». Entrez votre nom d'utilisateur et votre type d'accès (accès par programmation ou accès à AWS Management Console) et cliquez sur Suivant.
3. Attribuez des autorisations aux nouveaux utilisateurs. Nous pouvons ajouter directement des utilisateurs à un groupe d'utilisateurs existant (c'est-à-dire un ensemble d'utilisateurs associés aux mêmes autorisations) ou créer une politique d'autorisations personnalisée pour les nouveaux utilisateurs. Ici, nous créons une stratégie d'autorisations appelée « IAMUserPolicy » pour le nouvel utilisateur, y compris l'accès à AmazonS3FullAccess. Après avoir ajouté la politique d'autorisation, cliquez sur "Suivant".
4. Confirmez tous les paramètres. Sur cette page, nous pouvons afficher les clés d'accès et les informations d'identification de sécurité de l'utilisateur IAM que nous avons créé, ainsi que les autorisations d'accès que nous venons de créer pour cet utilisateur. Après avoir confirmé tous les paramètres, cliquez sur "Terminé".
5. Répétez les étapes 2 à 4 ci-dessus pour créer un rôle IAM nommé « IAMRole » et associer la stratégie d'autorisation AmazonS3FullAccess au rôle.

2. Implémenter AWS IAM en langage Go

Après avoir créé les utilisateurs et les rôles IAM, nous pouvons commencer à implémenter AWS IAM en langage Go. Voici les étapes de mise en œuvre à l'aide du kit AWS SDK for Go (aws-sdk-go) :

1. Installez aws-sdk-go :

go get -u github.com/aws/aws-sdk-go

2. Importez aws-sdk-go dans le code Go :

import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/iam"
)

3. Configuration Session AWS :

sess := session.Must(session.NewSessionWithOptions(session.Options{
    SharedConfigState: session.SharedConfigEnable,
}))

Cela lira le fichier de configuration partagé de l'AWS CLI/SDK, y compris les informations d'identification de sécurité et les informations sur la région.

4. Créer un client pour le service IAM :

svc := iam.New(sess)

Cela crée un client pour le service IAM.

5. Créer un utilisateur IAM :

_, err := svc.CreateUser(&iam.CreateUserInput{
    UserName: aws.String("test-user"),
})
if err != nil {
    panic(err)
}

Ici, nous avons créé un nouvel utilisateur IAM nommé « test-user ».

6. Attribuer des autorisations aux utilisateurs IAM :

_, err = svc.AttachUserPolicy(&iam.AttachUserPolicyInput{
    PolicyArn: aws.String("arn:aws:iam::aws:policy/AmazonS3FullAccess"),
    UserName:  aws.String("test-user"),
})
if err != nil {
    panic(err)
}

Ici, nous associons l'utilisateur IAM "test-user" à la stratégie d'autorisations AmazonS3FullAccess.

7. Créer un rôle IAM :

_, err = svc.CreateRole(&iam.CreateRoleInput{
    AssumeRolePolicyDocument: aws.String(`{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Principal": {
          "Service": "ec2.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
      }
    ]
}`),
    RoleName: aws.String("test-role"),
})
if err != nil {
    panic(err)
}

Ici, nous avons créé un nouveau rôle IAM appelé « test-role » et l'avons associé à Amazon EC2.

8. Attribuer des autorisations au rôle IAM :

_, err = svc.AttachRolePolicy(&iam.AttachRolePolicyInput{
    PolicyArn: aws.String("arn:aws:iam::aws:policy/AmazonS3FullAccess"),
    RoleName:  aws.String("test-role"),
})
if err != nil {
    panic(err)
}

Ici, nous associons le rôle IAM "test-role" à la stratégie d'autorisations AmazonS3FullAccess.

9. Liste de tous les utilisateurs IAM :

resp, err := svc.ListUsers(&iam.ListUsersInput{})
if err != nil {
    panic(err)
}
for _, user := range resp.Users {
    fmt.Println("IAM user:", *user.UserName)
}

Ici, nous répertorions tous les utilisateurs IAM.

10. Liste de tous les rôles IAM :

resp, err = svc.ListRoles(&iam.ListRolesInput{})
if err != nil {
    panic(err)
}
for _, role := range resp.Roles {
    fmt.Println("IAM role:", *role.RoleName)
}

Ici, nous avons répertorié tous les rôles IAM.

3. Conclusion

Dans cet article, nous avons présenté comment créer des utilisateurs et des rôles IAM dans AWS, et avons fourni des étapes détaillées et des exemples de code pour implémenter AWS IAM dans le langage Go à l'aide de aws-sdk-go. Grâce à IAM, nous pouvons mettre en œuvre une authentification et un contrôle d'accès fiables pour garantir la sécurité et la confidentialité des ressources AWS. Dans le même temps, grâce à la puissance d'aws-sdk-go, nous pouvons implémenter AWS IAM plus facilement et créer de meilleures applications dans le langage Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!