Comment puis-je décourager le partage de clés API internes au sein d'une entreprise?
Nous travaillons sur un nouveau service - ce service sera potentiellement appelé directement à partir d'applications sur les appareils des utilisateurs. Ces applications seront développées et prises en charge par plusieurs équipes de développement de toute l'organisation, toutes en fonction des données que nous fournissons.
Nous souhaitons identifier quelles applications envoient quelles demandes, afin d'identifier les modèles d'utilisation et les développeurs responsables. (Pour éviter tout doute, l'authentification des utilisateurs est gérée séparément.)
Notre solution consiste à exiger des clés API, une par application, puis nous avons les coordonnées de l'équipe de développement.
Nous ne voulons pas que les clés API soient une source de friction, mais nous craignons que les développeurs ne les partagent avec des collègues d'autres équipes, ce qui signifie que nous ne pouvons plus identifier le trafic pour une seule application.
Comment pouvons-nous inciter les développeurs à ne pas partager les clés API en interne?
Afin de partager ces clés entre les équipes, les équipes doivent se parler, accepter de partager, puis les partager. Cela prend du temps. Donc, si une équipe peut vous demander des clés d'API plus rapidement et plus facilement, il n'y a aucune incitation à partager.
Et le moyen le plus simple pour eux de demander ces clés est de les préempter. En supposant que vous connaissez toutes les autres équipes qui auront besoin de clés API, créez-les et partagez-les avant de mettre le service à leur disposition.
Il existe une autre incitation que vous pouvez offrir: le support du débogage. Ces équipes auront besoin de votre aide lorsque les choses ne fonctionnent pas tout à fait correctement lorsqu'elles intègrent leur travail à votre service. Ces clés API vous permettent de suivre leurs demandes spécifiques et ainsi d'aider au débogage de ce qui ne va pas. Vendez donc cela comme la raison des clés, plutôt que "identifiez les modèles d'utilisation et les développeurs responsables", ce qui semble que vous espionnez leurs activités.
Bonnes réponses déjà, je viens de penser à une approche différente qui peut ou non fonctionner pour vous.
Plutôt que d'émettre des clés à inclure, vous pourriez exiger que l'en-tête des demandes inclue le nom de l'application frontale, à créer et à formater par le développeur de l'application frontale, comme le font les navigateurs Web. De cette façon, les frontaux pourraient toujours prétendre être une application différente, mais il n'y aurait aucun avantage à le faire, ce qui semble peu probable. Laissez simplement le frontal s'identifier et acceptez toute chaîne non vide.
En bref:
Premièrement: facilitation et avantages; Si nécessaire: frictions et police.
Quelques mots de plus
Facilitation : Premièrement, il est facile pour une équipe d'obtenir une nouvelle clé API. Par exemple, ajoutez un rappel dans les procédures d'entreprise pour le lancement de nouveaux projets et offrez un service facile à utiliser pour demander de nouvelles clés, sans demander de justification.
Avantages : Faire de l'utilisation d'une propre clé API un avantage pour l'équipe ou le propriétaire du produit. Par exemple, proposez des commentaires sur l'utilisation de l'application en fonction de cette clé.
Friction : selon la fonctionnalité de la clé, vous pouvez créer une friction, par exemple si la clé est liée à un domaine défini par l'application (c.-à-d. Que la réutilisation des clés ne serait pas nécessairement donner accès à tous les services souhaités).
Police : Enfin, vous devrez peut-être prévoir des mesures de police. Par exemple, vous pouvez surveiller l'utilisation des fonctions api par touche api et après un certain temps pour établir une ligne de base, une enquête sur l'utilisation des parties api qui n'est pas attendue au vu de la ligne de base. Ou si cela n'est pas réaliste, incluez simplement dans les listes de contrôle de revue de projet d'entreprise la vérification qu'une clé valide a été utilisée.
Remarque: vous devrez peut-être être très clair sur votre stratégie de clé API: une nouvelle majeure version nécessite sa propre clé API? Avec une fourchette, ou si une application est divisée? si une autre équipe est en charge, etc ...
Généralement, le moyen le plus simple pour amener les développeurs à "faire la bonne chose" est de leur faciliter la tâche.
À cette fin, je suggère de créer une page/un site Web de délivrance de clés API. Dans sa forme la plus simple, il peut s'agir simplement d'une connexion (idéalement liée à votre AD/LDAP d'entreprise) et à la page qui demande simplement le nom de l'application et émet la clé.
À la fin de la journée, vous pouvez toujours révoquer les clés plus tard, donc tout ce que vous avez vraiment besoin du site est d'enregistrer qui (nom d'utilisateur) a demandé la clé et ce que (nom de l'application) ils veulent en faire - ainsi que toutes les informations nécessaires pour révoquer la clé plus tard.
Vous pourriez faire quelque chose de similaire avec un système de billetterie, mais en fin de compte, il est très facile pour moi de copier et coller une clé d'une application à une autre, il doit donc être très facile de demander une nouvelle clé, pour éviter les mauvaises comportement.
Comment pouvons-nous inciter les développeurs à ne pas partager les clés API en interne?
- Générez des clés suite à enregistrement d'application en libre-service.
- Nécessite un point de contact avant que les touches ne deviennent actives.
- Et demandez-leur de ne pas partager. (Créez des conditions de service et/ou dites-leur pourquoi il vaut mieux pour eux de ne pas partager.)
Vous devez également implémenter limiteur de débit. Cela en soi pourrait décourager le partage des clés. Il protège votre système dans une certaine mesure contre les applications abusives. (Et carrément malveillants.) Et, il garantit que vous serez quelque peu informé avant une augmentation massive du trafic en service. (Je vous donne le temps d'ajouter de la capacité, j'espère!)
Et, avec la limitation de débit, lorsqu'une application nécessite une limite supérieure, elle ouvre une boîte de dialogue avec le POC enregistré pour la clé. Vous avez la possibilité de demander si les clés sont partagées, d'expliquer pourquoi cela est nuisible, etc., et vous pouvez offrir des clés supplémentaires quand cela est approprié au lieu des changements de limite de taux demandés. Etc.
Etre pro-actif.
Identifiez les développeurs potentiels et donnez-leur à l'avance des clés API uniques dans un canal sécurisé. Fournissez un moyen simple de demander de nouvelles clés API. Fournir un moyen simple aux nouvelles personnes de demander de nouvelles clés API. Lorsque de nouveaux stagiaires ou embauchés rejoignent l'équipe, donnez-leur un ticket JIRA ou similaire "Demander une clé API" avec les étapes de la description.
Gardez une trace des clés API qui ont été utilisées et de celles qui ne l'ont pas été. Si Bob a soumis des tickets dans le projet mais n'a pas utilisé ses clés API, il a probablement emprunté celui de quelqu'un d'autre.
Bénéficiez du soutien de la direction. Ne soyez pas un Nosy Nancy en train de créer des règles qui n'ont pas d'importance. Convaincre littéralement la direction que c'est important, puis ce sont eux qui convainquent le groupe que c'est important. Ne travaillez pas à convaincre tout le monde.
Et la suggestion la plus agaçante et sujette à la tyrannie: soyez conscient des abus et réprimez le même jour. La même heure est la meilleure. Ne dites pas "Bad Naughty Developer", dites "Voici les étapes appropriées". S'ils le font à plusieurs reprises, désactivez la clé mal utilisée. Cela tracasse à la fois le partage et celui qui a emprunté, et le partage dira "Non, fais-le correctement" à l'avenir. Évitez de désactiver les clés qui se trouvent dans des projets en direct.
Une façon de faire les choses, surtout si les équipes utilisent un système de build partagé (ou au moins un système suffisamment commun) est de configurer un serveur interne qui crée et émet des clés API (compte tenu de quelques informations de base sur le produit qui l'utilise) ). Utilisez ensuite un script qui récupère une nouvelle clé API du serveur pour chaque version ou pour chaque mise à jour de version. Laissez les développeurs exécuter le script pour obtenir également une clé différente pour leurs versions locales. (Autant que possible, automatisez cela dans le cadre de la construction afin qu'ils n'aient même pas besoin d'y penser.)
Cela vous permettrait de dire s'il s'agissait de quelque chose en production, QA ou dev, et à quelle version/build les problèmes ont commencé.
La première et la meilleure chose que vous puissiez faire est de formater les clés afin qu'elles incluent le nom de l'application sous une forme facilement lisible, et ne fonctionnent pas si vous le modifiez.
S'il est évident que les équipes utilisent la mauvaise clé, elles s'efforceront de ne pas le faire.
Ensuite, expirez périodiquement les clés. Vous devez le faire de toute façon, et lorsqu'une clé arrive à expiration, vous pouvez en envoyer une nouvelle à l'équipe qui la possède. L'équipe qui utilise une clé sera alors motivée pour s'assurer qu'elle est bien la propriétaire, afin qu'elle obtienne la nouvelle à son expiration.