Déployer l'application de connexion dans OKE

Téléchargez le code à partir de GitHub, personnalisez-le et déployez-le.

L'exemple de code est disponible sur GitHub.

Allez à GitHub.
Copiez ou téléchargez le référentiel.
Suivez les instructions du document README.

Suivez ces étapes pour déployer l'application sur OKE :

Recherchez et clonez le référentiel GitHub.
Créez le fichier Dockerfile et créez une image.
Pousser l'image Docker vers le registre OCI.
définition des variables d'environnement;
Enregistrez l'application dans votre domaine d'identité.
Déployer l'image Docker dans une grappe OKE.
Testez l'expérience de connexion personnalisée avec votre exemple d'application de travail.

Référentiel Fork et Clone GitHub

Recherchez le référentiel GitHub pour créer une copie d'un référentiel sur votre machine de développement.

Ensuite, clonez le référentiel à fourche sur votre machine de développement à l'aide de la commande suivante.

git clone https://github.com:USERNAME/YOUR-FORKED-REPO

Créer un fichier Dockerfile

Créez un nouveau fichier nommé Dockerfile dans le référentiel cloné.

L'application de connexion personnalisée est une application Node JS. Le fichier Dockerfile ressemble à n'importe quelle application Node JS.

Utilisez l'exemple de fichier Dockerfile comme point de départ.

FROM node:alpine

# Create app directory WORKDIR /usr/src/app # Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied where available (npm@5+)
COPY package*.json ./
RUN npm install
# If you are building your code for production
# RUN npm install --only=production
# Bundle app source
COPY . .

EXPOSE 3000# "npm start" is how this would normally be startedCMD [ "npm", "start" ]

Vous pouvez utiliser la distribution Linux autorisée dans votre organisation au lieu de alpine.

Créer une image Docker

Utilisez la commande suivante pour créer une image Docker à partir du fichier Dockerfile et indiquez le nom de votre image.

docker build -t $IMAGE_NAME $PATH_TO_DOCKERFILE

Utilisez la commande suivante pour lister les images afin de vérifier votre image Docker.

docker images

Pousser l'image Docker vers le registre OCI

Pour pousser votre image Docker vers le registre OCI, procédez comme suit :

Connectez-vous à la console OCI.
Ouvrez votre menu Profil et cliquez sur Paramètres de l'utilisateur pour voir les détails.
Dans la page Jetons d'authentification, cliquez sur Créer un jeton pour en créer un nouveau.

Attention :
Copiez le jeton d'authentification et enregistrez-le dans un emplacement sécurisé pour l'extraire ultérieurement. Vous ne pouvez pas voir le jeton d'authentification plus tard dans votre console.
Fermez la boîte de dialogue Créer un jeton.
Exécutez la commande docker login <region-key>.ocir.io pour vous connecter au registre OCI (OCIR). Par exemple, pour la région Ashburn, exécutez docker login iad.ocir.io.

Entrez le nom d'utilisateur avec le jeton d'authentification dans ce format si l'utilisateur se trouve dans le domaine par défaut <tenancy-namespace>/<username>.

Pour un utilisateur de domaine IAM autre que par défaut, utilisez le format <tenancy-namespace>/<domain_name>/<username>.

À l'invite de mot de passe, entrez le jeton d'authentification Oracle Cloud Infrastructure de l'utilisateur.
Marquez et poussez l'image docker créée à l'étape précédente vers OCIR.
Vous pouvez créer un nouveau référentiel dans le registre de conteneurs OCI ou utiliser un référentiel existant. Le format du marqueur doit être <region-key>.ocir.io/<tenancy-namespace>/<repo-name>:<version>.
```
docker tag idcslogin:latest iad.ocir.io/mytenancy/myrepo/idcslogin:latest docker push iad.ocir.io/mytenancy/myrepo/idcslogin:latest
```
Le fichier manifeste Kubernetes utilisera cette image lors du déploiement d'un pod.
Vous pouvez également suivre ces instructions détaillées pour pousser votre image Docker vers le registre OCI.

L'image Docker est extraite dans le registre OCI et prête pour le déploiement.

Configurer les variables d'environnement

Obligatoire : IDCS_CLIENT_ID, IDCS_CLIENT_ID et IDCS_SECRET
Facultatif : IDCS_SELFREGPROFILES pour transmettre un profil d'auto-inscription à l'application de connexion et DEBUG_LOGIN=true pour activer la journalisation de débogage dans NodeJS
Production : NODE_ENV=variable de production

Utilisez les clés secrètes Kubernetes pour stocker ces valeurs et les transmettre dans le fichier manifeste.

Enregistrer l'application

Enregistrez une application de données d'identification de client dans IDCS ou le domaine d'identité afin que l'application de connexion personnalisée puisse effectuer des appels à l'API REST d'authentification d'Oracle Identity Cloud Service et permettre aux utilisateurs de se connecter.

Dans la console Oracle Identity Cloud Service, développez le tiroir de navigation, puis cliquez sur Applications.
Dans la page Applications, cliquez sur Ajouter.
Dans la boîte de dialogue Ajouter une application, cliquez sur Application approuvée ou Application confidentielle.
Dans le volet Détails, entrez les valeurs suivantes :
- Nom : Mon application de connexion
- Description : Mon application de connexion
Cliquez sur Suivant.
Dans le volet Client, sélectionnez Configurer cette application comme client maintenant, puis Données d'identification du client comme types de droits autorisés.
Dans le volet Client, faites défiler l'affichage vers le bas et cliquez sur Ajouter après Accorder au client l'accès aux API d'administration d'Identity Cloud Service.
Dans la boîte de dialogue Ajouter un rôle d'application, sélectionnez Connexion, Vérifier le courriel, Réinitialiser le mot de passe, Mot de passe oublié et Auto-inscription dans la liste, puis cliquez sur Ajouter.
Cliquez sur Suivant dans le volet Client et dans les volets suivants jusqu'à ce que vous atteigniez le dernier volet.
Cliquez sur Terminer.
Dans la boîte de dialogue Application ajoutée, notez les valeurs ID client et Clé secrète client, puis cliquez sur Fermer.
Pour activer l'application, cliquez sur Activer.
In the Activate Application? dialog, click Activate Application.
Un message de réussite apparaît.

Créer une grappe OKE

Suivez les instructions pour créer une grappe OKE si vous n'en avez pas déjà une.
Assurez-vous d'avoir accès à la nouvelle grappe à l'aide de kubectl. Suivez les étapes de la section Démarrage rapide pour accéder à votre grappe.

Déployer l'application dans la grappe OKE

Pour créer un fichier manifeste de déploiement Kubernetes et déployer l'application sur OKE, procédez comme suit :

Créez une valeur Kubernetes Secret pour rendre tous les paramètres de configuration disponibles pour votre grappe OKE.
1. Configurer les paramètres de configuration du service IAM pour OCI.
```
$ kubectl create secret generic idcs_config --from-literal=url=https://<domain instanceid>.identity.oraclecloud.com --from-literal=client-id=<client_id_of_sign_in_app> --from-literal=client-secret=<client_secret_of_sign_in_app>
```
2. Créez un jeton de registre OCI.
```
$ kubectl create secret generic idcs_config --from-literal=url=https://<domain instanceid>.identity.oraclecloud.com --from-literal=client-id=<client_id_of_sign_in_app> --from-literal=client-secret=<client_secret_of_sign_in_app>
```
3. La clé et le certificat SSL du service d'équilibreur de charge sont requis pour configurer un point d'extrémité HTTPS permettant d'accéder à l'application personnalisée à l'aide de l'équilibreur de charge. Créez une nouvelle paire de clés pour votre équilibreur de charge.
4. Créez une clé secrète Kubernetes pour la rendre disponible pour votre grappe OKE.
```
$ kubectl create secret tls ssl-certificate-secret --key your.key --cert your.crt
```
  Note :
  Oracle recommande de configurer le service d'équilibreur de charge avec le port SSL, sauf à des fins de développement ou de test rapide.

Créez un fichier manifeste de déploiement Kubernetes.

Le fichier contient une spécification de pod pour l'application personnalisée et une spécification de service pour l'équilibreur de charge.

Les paramètres de configuration tels que le jeton OCIR et la configuration IAM OCI sont transmis en tant que variables d'environnement et les valeurs sont extraites de la clé secrète Kubernetes que vous avez créée lors des étapes précédentes.

Le chemin de l'image de conteneur Docker de l'application doit être le chemin OCIR de l'image.

Voici un exemple de fichier YAML nommé customlogin.yaml.

apiVersion: v1
kind: Pod
metadata:
  name: login-app
  labels:
    app: customlogin
spec:
  containers:
    - name: idcslogin
      image: iad.ocir.io/<tenancy namespace>/idcslogin:latest
      imagePullPolicy: Always
      ports:
      - name: httpport
        containerPort: 3000
        protocol: TCP
      env:
      - name: IDCS_URL
        valueFrom:
          secretKeyRef:
            name: idcs-config
            key: url
      - name: IDCS_CLIENT_ID
        valueFrom:
          secretKeyRef:
            name: idcs-config
            key: client-id
      - name: IDCS_CLIENT_SECRET
        valueFrom:
          secretKeyRef:
            name: idcs-config
            key: client-secret

  imagePullSecrets:
    - name: ocirsecret
---

apiVersion: v1
kind: Service
metadata:
  name:
 loginlb
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-ssl-ports: "443"
    service.beta.kubernetes.io/oci-load-balancer-tls-secret: ssl-certificate-secret
  labels:
    app: loginlb
spec:
  selector:
    app: customlogin
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 3000
  - name: https
    port: 443
    protocol: TCP
    targetPort: 3000

Note :

Pour connaître l'espace de noms de la location courante, ouvrez le menu Profil et cliquez sur Location. L'espace de noms de la location est affiché dans le champ Espace de noms du stockage d'objets.

Déployez le pod d'application personnalisé et le service d'équilibreur de charge dans votre grappe OKE.

$ kubectl apply -f ./customlogin.yaml

$ kubectl get all

Nom	Prêt	Statut	Redémarrages	Ancienneté
`pod/login-app`	`1/1`	`Running`	`0`	`12d`

Nom	Type	Cluster-IP	Externe-IP	Port(s)	Ancienneté
`service/kubernetes`	`ClusterIP`	`10.96.0.1`	`None`	`443/TCP`	`109d`
`service/loginlb`	`LoadBalancer`	`10.96.45.133`	`10.1.1.1`	`80:31420/TCP, 443:30563/TCP`	`12d`

Tester l'expérience de connexion personnalisée

Suivez ces étapes pour tester l'expérience de connexion à l'aide de l'exemple d'application de travail que vous avez préparé pour le test :

Mettez à jour l'exemple d'application pour utiliser l'URL de l'équilibreur de charge de l'application personnalisée nouvellement déployée.
Dans votre exemple d'application, entrez l'URL de l'équilibreur de charge dans le champ URL de connexion personnalisée. Cette URL peut être l'adresse IP publique de l'équilibreur de charge ou le nom de domaine complet en fonction de votre entrée DNS.
Accédez à l'exemple d'URL d'application dans le navigateur.
Vous devez accéder à la page de l'application de connexion personnalisée.