web-dev-qa-db-fra.com

Méthode recommandée pour gérer les informations d'identification avec plusieurs comptes AWS?

Quel est le meilleur moyen de gérer plusieurs comptes Amazon Web Services (AWS) via boto?

Je connais bien les fichiers BotoConfig , que j'utilise. Mais chaque fichier ne décrit qu'un seul compte ... et je travaille avec plusieurs organisations. Pour toutes les raisons légales, financières et de sécurité habituelles, ces comptes ne peuvent pas être mélangés. 

Actuellement, j'utilise un fichier de configuration boto par compte. Par exemple.:

  • ~/.boto compte par défaut
  • ~/.boto_clowncollege pour le compte "clowncollege"
  • ~/.boto_razorassoc pour le compte "razorassoc"
  • ~/.boto_xyz pour le compte "xyz"

Puis quelque chose comme:

def boto_config_path(account=None):
    """
    Given an account name, return the path to the corresponding boto
    configuration file. If no account given, return the default config file.
    """
    path = '~/.boto' + ('_' + account if account else '')
    clean_path = os.path.abspath(os.path.expanduser(path))
    if os.path.isfile(clean_path):
        return clean_path
    else:
        errmsg = "cannot find boto config file {} for {}".format(clean_path, account)
        raise ValueError(errmsg)

def aws_credentials(account=None):
    """
    Return a Tuple of AWS credentials (access key id and secret access key) for
    the given account.
    """
    try:
        cfg = INIConfig(open(boto_config_path(account)))
        return ( cfg.Credentials.aws_access_key_id, cfg.Credentials.aws_secret_access_key )
    except Exception:
        raise

conn = EC2Connection(*aws_credentials('razorassoc'))

Bon, mauvais ou indifférent? Améliorations suggérées?

pythonamazon-web-servicesboto
26
Jonathan Eunice

À l'avenir, boto fournira de meilleurs outils pour vous aider à gérer plusieurs identifiants, mais pour le moment, quelques variables d'environnement pourraient vous aider.

Tout d'abord, vous pouvez définir BOTO_CONFIG pour qu'il pointe vers un fichier de configuration boto que vous souhaitez utiliser, ce qui remplacera tout fichier de configuration trouvé dans les emplacements normaux.

Deuxièmement, vous pouvez définir BOTO_PATH sur une liste d'emplacements séparés par des points-virgules pour rechercher un fichier de configuration boto. Cette recherche sera effectuée en premier, avant les emplacements de recherche habituels.

Aucune de celles-ci ne vous donne exactement ce que vous voulez, mais cela peut faciliter la tâche avec un peu moins de code.

Si vous avez des idées sur la façon dont vous souhaitez que cela fonctionne dans boto, s'il vous plaît faites le moi savoir!

7
garnaat

mis à jour le 2015-02-06, corrigé le 19/03/2015 en suivant la section du haut

Nouveau partage normalisé des informations d'identification boto et AWSCLI (boto> == 2.29.0)

Depuis boto 2.29, il existe un nouveau moyen simple de partager les informations d'identification BOTO et AWS CLI, comme décrit par Mike Garnaat dans Une nouvelle méthode standard de gestion des informations d'identification dans les kits AWS AWS .__

Le but est de: 

  1. autoriser le partage des informations d'identification par boto, AWSCLI et éventuellement d'autres SDK
  2. conserver toute la configuration dans un seul fichier, situé dans le répertoire du profil de l'utilisateur
  3. autoriser l'utilisation de profils nommés
  4. gardez-le aussi simple que possible (par exemple, évitez les conflits avec d'autres méthodes)

Créer un fichier d'informations d'identification

Créez le fichier ~/.aws/credentials (Mac/Linux) ou %USERPROFILE%\.aws\credentials (Windwos) en tant que Comme suit:

[default]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr
region = eu-west-1

[jekyl]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr
region = eu-west-1

[hyde]
aws_access_key_id = AxxxZ
aws_secret_access_key = CxxxZ
region = eu-west-1

A partir de maintenant, vous pouvez utiliser un code comme celui-ci:

Utiliser le profil par défaut

import boto
con = boto.connect_s3()

Utiliser le profil explicite défini par AWS_PROFILE env. var

(Il s'agit de mon option préférée: conserver le nom de profil en dehors du code tout en laissant au déployeur de mon application une chance de choisir un profil spécifique.) 

$ export AWS_PROFILE=jekyl

et gardez votre code aussi simple qu'avant:

import boto
con = boto.connect_s3()

Spécifiez un profil explicite dans votre code

import boto
con = boto.connect_s3(profile_name="jekyl")

C'est tout ce que vous devez généralement faire

La logique de sélection des informations d'identification appropriées est décrite dans le problème n ° 2292 comme suit:

L'ordre de chargement de la priorité la plus élevée à la plus basse:

1. directement passé du code

  1. Variables d'environnement pour clé/secret

  2. Variables d'environnement pour le profil

  3. Profil explicite de fichier d'informations d'identification partagé

  4. Profil par défaut du fichier d'informations d'identification partagé

  5. Profil explicite du fichier de configuration

  6. Section Informations d'identification du fichier de configuration

Un profil transmis à partir du code remplace tout ensemble d'une variable d'environnement.

Pour garder les choses simples et nettes, il est bon de se débarrasser des anciennes méthodes. Supprimez donc tous les anciens fichiers de style (tels que ~/.aws/config ou ~/.boto), définissez varialbe environment BOTO_CONFIG s'il est défini et Éventuellement également le fichier sur lequel pointent ces variables à.

Et c'est vraiment tout pour boto> = 2.29.0

Remarque: N'essayez pas de contrôler l'emplacement du fichier de configuration avec env.variable (comme AWS_CONFIG_FILE), cela ne fonctionne pas comme prévu.

Utiliser le profil de configuration boto (boto> = 2.24.0)

La description suivante est conservée ici uniquement pour ceux qui ne peuvent pas passer à boto 2.29.0 ou supérieur

Depuis boto 2.24.0, il existe une fonctionnalité appelée profile_name

Dans votre fichier ~/.boto, vous avez déjà votre section [Credentials], elle servira d'option de secours, puis des sections [profile] servant pour différents profils:

[Credentials]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr

[profile jekyl]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr

[profile hyde]
aws_access_key_id = AxxxZ
aws_secret_access_key = CxxxZ

Ensuite, lors de la création d'une connexion, vous utilisez cette méthode:

import boto
con = boto.connect_s3(profile_name="jekyl")

Notez que cette fonctionnalité est disponible depuis boto 2.24.0.

Le didacticiel est ici http://docs.pythonboto.org/fr/latest/boto_config_tut.html?highlight=profile

Il y a même quelques notes sur l'utilisation de trousseaux de clés, mais je vais d'abord m'habituer à ce profil, ce dont je rêvais depuis quelques années.

Partage du fichier de configuration avec AWSCLI

AWSCLI est devenu un très bon outil. Comme le format du fichier de configuration est presque identique, je l’utilise de la manière suivante:

  1. conserve le fichier ~/.aws/config créé par AWSCLI (il s'agit de l'emplacement par défaut)
  2. copiez la section [default] et renommez-la en [Credentials] (en laissant les mêmes valeurs à l'intérieur).
  3. ajouter les profils que j'utilise
  4. définissez la variable BOTO_CONFIG pour qu'elle pointe vers ce fichier ~/.aws/config.

Le ~/.boto deviendrait alors `~/.aws/config avec le contenu suivant:

[default]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr

[Credentials]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr

[profile jekyl]
aws_access_key_id = AxxxA
aws_secret_access_key = Zxxxr

[profile hyde]
aws_access_key_id = AxxxZ
aws_secret_access_key = CxxxZ

De cette façon, il est partagé pour AWSCLI et boto, y compris les profils.

65
Jan Vlcinsky

Plutôt que de créer un ensemble de fichiers de configuration distincts, utilisez le module ConfigParser et créez une section dans le fichier .boto pour chacun de vos comptes.

votre fichier .boto pourrait ressembler à ceci

#Contents of ~/.boto
[clown-college]
aws_access_key_id = 123sesamestreet
aws_secret_access_key = 678idsaf567ujd
[razor-assoc]
aws_access_key_id = 437piedmont
aws_secret_access_key = 997567ujdfs

Dans votre code python, utilisez ConfigParser pour charger la clé d'accès appropriée pour le compte que vous souhaitez utiliser.

import ConfigParser
from os.path import expanduser

########## BEGIN MAIN ##############

# get the path to the user's homedir
user_home = expanduser("~")

#load their .boto config file
config = ConfigParser.ConfigParser()
config.read([str(user_home + "/.boto")])

#get the keypair for ClownCollege
print config.get('clown-college', 'aws_access_key_id')
print config.get('clown-college', 'aws_secret_access_key')

print config.get('razor-assoc', 'aws_access_key_id')
print config.get('razor-assoc', 'aws_secret_access_key')

Cela peut être encapsulé dans une fonction à utiliser dans votre code boto pour définir facilement le compte approprié.

5
redmax

Notez que pour http://boto.cloudhackers.com/en/latest/boto_config_tut.html - lors de l’utilisation de connect_cloudwatch () pour boto version 2.48.0, j’avais besoin de fournir le

cloudwatch_region_endpoint 

Ou bien la connexion utiliserait toujours la même région que l'instance actuelle lors du transfert des données de l'instance elle-même dans EC2 (lorsque l'instance se trouve dans une région différente de celle où elle est poussée).

cat .boto
[Boto]
cloudwatch_region_name = us-west-2
cloudwatch_region_endpoint = monitoring.us-west-2.amazonaws.com

J'ai essayé d'ajouter cela au profil .aws/credentials, mais cela ne semblait pas fonctionner.

cat .aws/credentials 
[cloudwatch_centralized_reporting]
region = us-west-2
aws_access_key_id = XXX
aws_secret_access_key = XXX
0
storm_m2138