|
Prérequis
- Un serveur Ubuntu 20.04 avec un utilisateur non root avec les privilèges « sudo ».
- Un cluster Kubernetes installé sur le serveur, comme `kubeadm`, `k3s`, `minikube`, `Rancher`, etc.
- Accès à la fenêtre de ligne de commande/terminal.
Étape 1 :Mettre à jour le système
Mettez à jour vos listes de packages avant de procéder à toute installation :
``` merde
sudo apt update &&sudo apt update -y
```
Étape 2 : Ajouter le référentiel de passerelle Kong Kong
Importez la clé GPG pour le référentiel Kubernetes, qui permet d'identifier l'éditeur du package.
``` merde
boucle https://download.konghq.com/keyring/kong.gpg | sudo apt-key ajouter -
```
Créez la liste des référentiels Kong afin qu'apt puisse obtenir Kong à partir de la source officielle.
``` merde
echo "deb [arch=amd64] https://download.konghq.com/deb stable main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Étape 3 :Installer Kong Gateway
Maintenant, installez Kong Gateway à l'aide du gestionnaire de packages standard, apt.
``` merde
sudo apt installer kong
```
Cette commande devrait installer Kong Gateway et toutes ses dépendances.
Étape 4 :Activer et vérifier le service Kong
Une fois l'installation terminée, exécutez la commande suivante pour activer le service Kong :
``` merde
sudo systemctl activer kong
```
Et puis, démarrez le service Kong :
``` merde
sudo systemctl démarrer kong
```
Pour vérifier si le service Kong est en cours d'exécution, utilisez la commande suivante :
``` merde
sudo systemctl statut kong
```
Étape 5 :Installer le contrôleur d'entrée
Ensuite, nous installerons le Kong Ingress Controller, qui fait office de pont entre Kong Gateway et Kubernetes.
Exécutez la commande suivante pour installer Kong Ingress Controller à l'aide de Helm, le gestionnaire de packages Kubernetes :
``` merde
helm repo ajouter kong https://charts.konghq.com
mise à jour du dépôt de barre
helm installe kong/kong-ingress-controller --namespace=kong --create-namespace
```
Cela installe Kong Ingress Controller dans un espace de noms « kong » nouvellement créé.
Étape 6 :Configuration de l'accès au trafic externe à Kong Gateway
Par défaut, Kong Gateway écoute les requêtes sur l'interface locale et le port 8000. Pour autoriser l'accès à distance depuis l'extérieur de votre serveur, par exemple depuis les clients de votre cluster, nous devons configurer les politiques réseau de Kubernetes.
Créez la politique réseau nécessaire à l'aide de `kubectl` :
``` merde
kubectl créer -f - <
Version api :networking.k8s.io/v1
genre : Politique de réseau
métadonnées :
nom :autoriser le trafic
spécification :
podSélecteur :{}
entrée:
- depuis:
- sélecteur d'espace de noms :
matchLabels :
nom :Kong
ports :
-port :8000
protocole : TCP
EOF
```
Cette politique réseau permet à tous les pods de l'espace de noms « kong » d'envoyer du trafic à Kong Gateway.
Étape 7 : Test de la passerelle Kong
Pour tester si Kong Gateway fonctionne comme prévu, envoyez-lui une demande. Exécutez la commande suivante pour envoyer une requête HTTP à l'aide de « curl ».
``` merde
curl -IL http://localhost:8000
```
Vous devriez recevoir une réponse HTTP 404, indiquant que Kong Gateway reçoit la demande mais qu'aucun itinéraire ou service correspondant n'est disponible.
Étape 8 :Intégration avec les services Kubernetes
Pour terminer la configuration, vous pouvez déployer une application simple dans votre cluster Kubernetes et utiliser Kong Gateway comme contrôleur d'entrée pour acheminer les requêtes vers l'application.
Voici un exemple de manifeste de « déploiement » pour une application simple nommée « nginx » :
```yaml
Version api : apps/v1
genre :Déploiement
métadonnées :
nom :nginx
étiquettes :
application :nginx
spécification :
sélecteur:
matchLabels :
application :nginx
répliques :1
modèle:
métadonnées :
étiquettes :
application :nginx
spécification :
conteneurs :
- nom :nginx
image : nginx : 1.21
ports :
- port conteneur :80
nom :http
```
Enregistrez-le dans un fichier nommé « nginx.yaml ». Ensuite, déployez-le sur votre cluster Kubernetes :
``` merde
kubectl apply -f nginx.yaml
```
Cela crée un déploiement pour un simple serveur Nginx.
#### Création du service
Ensuite, créez un service Kubernetes qui expose le port 80 de tous les pods avec l'étiquette « app=nginx » :
```yaml
Version api : v1
genre : Service
métadonnées :
nom :nginx
étiquettes :
application :nginx
spécification :
ports :
- port :80
nom :http
sélecteur:
application :nginx
```
Enregistrez-le dans un fichier nommé « nginx-service.yaml ». Ensuite, déployez-le sur votre cluster Kubernetes :
``` merde
kubectl apply -f nginx-service.yaml
```
#### Création de la KongRoute
Enfin, configurez Kong Gateway pour acheminer le trafic vers notre service « nginx ». Vous trouverez ci-dessous un exemple de manifeste pour un KongRoute :
```yaml
Version api :konghq.com/v1
genre :KongRoute
métadonnées :
nom :exemple
spécification :
protocoles :
-https
hôte :exemple.com
chemins :
-/
service:
nom :nginx-kong
port :80
protocole :http
```
Enregistrez ce manifeste dans un fichier nommé « example-route.yaml » et appliquez-le à votre cluster Kubernetes :
``` merde
kubectl apply -f exemple-route.yaml
```
Cela crée une configuration, indiquant à Kong Gateway d'accepter les requêtes HTTPS vers le domaine « exemple.com » et de les acheminer vers notre service « nginx » exécuté sur le port 80 en utilisant HTTP.
Test du routage
Vous pouvez maintenant tester le routage Kong Gateway. Depuis n'importe quelle machine ayant accès au cluster Kubernetes, exécutez :
``` merde
curl -k https://exemple.com
```
Si tout est correctement configuré, vous devriez voir la page d'accueil par défaut de Nginx.
Félicitations! Vous avez installé avec succès Kong Gateway sur Ubuntu Linux, configuré le contrôleur d'entrée, configuré les politiques réseau et testé le routage vers une application de votre cluster Kubernetes.
|
