Cinq conseils pour utiliser l'API Java

Cet article présente principalement en détail les techniques simples et faciles à utiliser dans la sécurité et les performances de l'API Java. Il a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Cet article présente quelques éléments faciles à utiliser. -utiliser des conseils pour la sécurité et les performances de l'API Java, y compris des suggestions pour assurer la sécurité des clés API et des choix de framework pour le développement de services Web.

Les programmeurs adorent utiliser les API ! Par exemple, créer des API pour des applications d'application ou dans le cadre d'une architecture de microservices. Bien entendu, le principe de l’utilisation de l’API est de faciliter votre travail. Les efforts visant à simplifier le développement et à améliorer l’efficacité du travail impliquent parfois de trouver de nouvelles bibliothèques ou de nouveaux processus (ou de réduire les processus). Pour de nombreuses équipes de développement, la gestion de l'authentification et du contrôle d'accès pour leurs applications et API prend beaucoup de temps. Nous aimerions donc partager quelques conseils qui peuvent vous faire gagner du temps, réduire la quantité d'écriture de code et rendre vos applications plus sécurisées et plus simples. à maintenir.

Permettez-moi d'abord de vous présenter les connaissances de base mentionnées dans cet article : Okta est une application Java construite sur la base de l'API REST et JSON, construite à l'aide du framework Spring. Les applications de notre entreprise stockent les informations d'identification des utilisateurs et les données sensibles d'autres entreprises. La sécurité est donc la chose la plus importante pour nous. Par conséquent, ma première demande concernant ces conseils est qu’ils peuvent contribuer à rendre vos applications Java plus sécurisées.

Ces suggestions devraient être communes à tout type d'application Java. Ils vous aideront à écrire du code plus rapidement, mais avec moins de code et de manière plus sécurisée : c'est vraiment gagnant-gagnant-gagnant !

1. N'implémentez pas le cadre de sécurité vous-même

Sérieusement, n'essayez pas d'implémenter le code de sécurité vous-même, c'est trop difficile.

Presque tout le monde sait qu'il faut éviter de mettre en œuvre des algorithmes tels que le cryptage. De la même manière, le reste de la pile de sécurité de votre application peut être coûteux et risqué. Vous ferez très probablement des erreurs. Depuis 1999, 89 373 CVE (Public Vulnerabilities and Exposures) ont été publiées. Et les découvreurs de la plupart d’entre eux sont des gens très intelligents.

Vous pourriez penser que gérer un cas d'utilisation simple (comme la validation du mot de passe d'un utilisateur) est trivial : tout ce que vous faites est de comparer une paire de chaînes. Ce serait une erreur de le penser. Vous devez vérifier les hachages de mots de passe, auditer les tentatives de connexion, atténuer les attaques par dictionnaire, et ce n’est que la pointe de l’iceberg. Votre meilleure option consiste à utiliser des bibliothèques ou des frameworks matures existants, tels que Shiro ou Spring Security d'Apache, et à laisser ces frameworks gérer divers problèmes de sécurité complexes.

2. Utilisez TLS, toujours ! Utilisez toujours TLS ! 　

Nous sommes en 2017 et tous les sites Web devraient utiliser HTTPS, même l'intranet de l'entreprise. Let's Encrypt rend le HTTPS facile et simple, ce qui signifie que vous ne pouvez plus utiliser de clés auto-signées non sécurisées ! Vous pouvez même configurer une instance locale Tomcat ou Nginx avec authentification par certificat.

Il suffit d'une simple ligne de code pour que votre application nécessite TLS (HTTPS/SSL), tout le monde devrait le faire ! Si vous utilisez le framework Apache Shiro, il vous suffit de définir les propriétés :

[urls]/** = ssl

Si vous utilisez Spring Security, il vous suffit d'appeler simplement une méthode lors de la configuration HttpSécurité.

http.requiresChannel()
.anyRequest().requiresSecure();

Dans Spring Boot, il vous suffit de définir certaines propriétés, comme suit :

server.port=8443
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=secret
server.ssl.key-password=another-secret

3. Utilisez Spring Boot pour créer un service Web

Spring Boot est une simplification de la plateforme Spring, qui facilite l'écriture d'applications Spring. Par exemple, il peut utiliser. très peu de code à écrire Le point mentionné dans l'article "12 facteurs à prendre en compte dans les applications". Si vous codez encore en créant des packages War, alors Spring Boot vaut la peine d'être appris. Spring Boot peut être utilisé pour créer des types d'applications complexes et différents. Par exemple, vous pouvez utiliser une simple annotation (@EnableResourceServer) pour créer un serveur de ressources OAuth, ou modifier son port via un simple attribut :

server.port = 8090

Si vous n'aimez pas utiliser SpringBoot, vous pouvez utiliser Dropwizard pour créer une pile technologique JAX-RS.

4. Surveiller les applications et les indicateurs de performance

Il est difficile de trouver des erreurs de programme sans aucune donnée. Spring Boot facilite la collecte de données d'indicateur à l'aide d'Actuator. Il vous suffit d'ajouter une dépendance à l'application, comme suit :

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>`

Vous pouvez ensuite utiliser le. navigateur, saisissez /health ou /metrics après avoir accédé à l'adresse de l'application pour vérifier l'état de santé ou les indicateurs de l'application. Le framework Dropwizard implémente la même fonctionnalité via /healthcheck et /metrics.

Voici le résultat généré par l'application Spring Boot via /metrics :

  {
  "classes": 7704,
  "classes.loaded": 7704,
  "classes.unloaded": 0,
  "counter.status.200.metrics": 1,
  "gauge.response.metrics": 99.0,
  "gc.ps_marksweep.count": 2,
  "gc.ps_marksweep.time": 272,
  "gc.ps_scavenge.count": 8,
  "gc.ps_scavenge.time": 136,
  "heap": 3728384,
  "heap.committed": 470016,
  "heap.init": 262144,
  "heap.used": 207793,
  "httpsessions.active": 0,
  "httpsessions.max": -1,
  "instance.uptime": 25020,
  "mem": 529086,
  "mem.free": 262222,
  "nonheap": 0,
  "nonheap.committed": 60608,
  "nonheap.init": 2496,
  "nonheap.used": 59067,
  "processors": 8,
  "systemload.average": 5.56103515625,
  "threads": 24,
  "threads.daemon": 22,
  "threads.peak": 28,
  "threads.totalStarted": 32,
  "uptime": 37182}

5. Protéger les informations sensibles

人们都认为API密钥是不安全的，这是事实。密钥通过电子邮件发送或源代码管理系统控制。也许这是它们看起来比密码更不安全的原因，但它们也一样敏感。如果需要将API密钥存储在文件中，请确保授予文件有限的访问权限。例如，我们建议在私人目录中存放Okta的YAML文件并且赋予文件所有者只读权限。

$ chmod u=r,go-rwx ~/.okta/okta.yaml

如果你正为使用你的APP的用户创建API，记得提醒他们，如果无设置好权限的话，.SSH的忽文件是放在你的~/.ssh目录下，如果无设置好权限的话。GitHub 把它们放在“危险区域”，以提醒用户，这是十分有用的。

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!