Anmeldeanwendung in OKE bereitstellen

Laden Sie den Code von GitHub herunter, passen Sie ihn an, und stellen Sie ihn bereit.

Der Beispielcode ist auf GitHub verfügbar.

Gehen Sie zu GitHub.
Kopieren Sie das Repository, oder laden Sie es herunter.
Befolgen Sie die Anweisungen im README-Dokument.

Führen Sie die folgenden Schritte aus, um die Anwendung in OKE bereitzustellen:

Fork und Klonen des GitHub-Repositorys.
Erstellen Sie die Dockerfile, und erstellen Sie ein Image.
Docker-Image in OCI Registry übertragen.
Richten Sie Umgebungsvariablen ein.
Registrieren Sie die Anwendung in Ihrer Identitätsdomain.
Stellen Sie das Docker-Image in einem OKE-Cluster bereit.
Testen Sie die benutzerdefinierte Anmeldeerfahrung mit Ihrer Arbeitsbeispielanwendung.

Repository GitHub von Fork und Clone

Fork das Repository GitHub, um eine Kopie eines Repositorys auf dem Entwicklungsrechner zu erstellen.

Klonen Sie dann das Gabel-Repository auf dem Entwicklungsrechner mit dem folgenden Befehl.

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

Dockerfile erstellen

Erstellen Sie eine neue Dateinamen-Dockerfile im geklonten Repository.

Die benutzerdefinierte Anmeldeanwendung ist eine Node JS-Anwendung. Die Dockerfile ähnelt einer beliebigen Node JS-Anwendung.

Verwenden Sie das folgende Beispiel-Dockerfile als Ausgangspunkt.

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" ]

Sie können die in Ihrer Organisation zulässige Linux-Distribution anstelle von alpine verwenden.

Docker-Image erstellen

Verwenden Sie den folgenden Befehl, um ein Docker-Image aus der Dockerfile zu erstellen und Ihren Imagenamen anzugeben.

docker build -t $IMAGE_NAME $PATH_TO_DOCKERFILE

Mit dem folgenden Befehl können Sie die Images auflisten, um Ihr Docker-Image zu verifizieren.

docker images

Docker-Image an OCI Registry übertragen

So übertragen Sie Ihr Docker-Image an die OCI Registry:

Melden Sie sich bei der OCI-Konsole an.
Öffnen Sie das Menü Profil, und klicken Sie auf Benutzereinstellungen, um die Details anzuzeigen.
Klicken Sie auf der Seite Auth-Token auf Token generieren, um ein neues Token zu erstellen.

Achtung:
Kopieren Sie das Authentifizierungstoken, und speichern Sie es an einem sicheren Speicherort, um es später abzurufen. Das Authentifizierungstoken wird später in der Konsole nicht angezeigt.
Schließen Sie das Dialogfeld Token generieren.
Führen Sie den Befehl docker login <region-key>.ocir.io aus, um sich bei der OCI Registry (OCIR) anzumelden. Beispiel: Führen Sie für die Region Ashburn docker login iad.ocir.io aus.

Geben Sie den Benutzernamen mit dem Authentifizierungstoken in diesem Format ein, wenn sich der Benutzer in der Standarddomain <tenancy-namespace>/<username> befindet.

Verwenden Sie für Nicht-Standardbenutzer der IAM-Domain das Format <tenancy-namespace>/<domain_name>/<username>.

Wenn Sie zur Eingabe des Kennworts aufgefordert werden, geben Sie das Oracle Cloud Infrastructure-Authentifizierungstoken des Benutzers ein.
Taggen und übertragen Sie das im vorherigen Schritt erstellte Dockerimage an OCIR.
Sie können entweder ein neues Repository in der OCI-Container-Registry erstellen oder ein vorhandenes Repository verwenden. Das Format des Tags muss <region-key>.ocir.io/<tenancy-namespace>/<repo-name>:<version> lauten.
```
docker tag idcslogin:latest iad.ocir.io/mytenancy/myrepo/idcslogin:latest docker push iad.ocir.io/mytenancy/myrepo/idcslogin:latest
```
Die Kubernetes-Manifestdatei verwendet dieses Image beim Deployment eines Pods.
Alternativ können Sie diese detaillierten Anweisungen befolgen, um Ihr Docker-Image an OCI Registry zu übertragen.

Das Docker-Image wird in die OCI Registry übernommen und ist bereit für das Deployment.

Umgebungsvariablen einrichten

Erforderlich: IDCS_CLIENT_ID, IDCS_CLIENT_ID und IDCS_SECRET
Optional: IDCS_SELFREGPROFILES, um ein Selbstregistrierungsprofil an die Anmeldeanwendung zu übergeben, und DEBUG_LOGIN=true, um das Debuglogging in NodeJS zu aktivieren
Produktion: NODE_ENV=Produktionsvariable

Verwenden Sie Kubernetes-Secrets, um diese Werte zu speichern und in der Manifestdatei weiterzugeben.

Anwendung registrieren

Registrieren Sie eine Clientzugangsdatenanwendung in IDCS oder Identitätsdomain, damit die benutzerdefinierte Anmeldeanwendung Aufrufe der Oracle Identity Cloud Service-Authentifizierungs-REST-API ausführen und Benutzer sich anmelden können.

Blenden Sie in der Oracle Identity Cloud Service-Konsole das Slide-in-Menü ein, und klicken Sie auf Anwendungen.
Klicken Sie auf der Seite Anwendungen auf Hinzufügen.
Klicken Sie im Dialogfeld Anwendung hinzufügen auf Vertrauenswürdige Anwendung oder Vertrauliche Anwendung.
Geben Sie im Bereich Details die folgenden Werte ein:
- Name: Meine Anmeldeanwendung
- Beschreibung: Meine Anmeldeanwendung
Klicken Sie auf Weiter.
Wählen Sie im Bereich Client die Option Diese Anwendung jetzt als Client konfigurieren aus, und wählen Sie unter Zulässige Berechtigungstypen die Option Clientzugangsdaten aus.
Scrollen Sie im Bereich Client nach unten, und klicken Sie nach Client Zugriff auf die Identity Cloud Service-Admin-APIs erteilen auf Hinzufügen.
Wählen Sie im Dialogfeld Anwendungsrolle hinzufügen die Optionen Anmelden, E-Mail verifizieren, Kennwort zurücksetzen, Kennwort vergessen und Selbstregistrierung in der Liste aus, und klicken Sie auf Hinzufügen.
Klicken Sie im Bereich Client und in den folgenden Bereichen bis zum letzten Bereich auf Weiter.
Klicken Sie auf Fertig stellen.
Notieren Sie sich im Dialogfeld Anwendung hinzugefügt die Client-ID und die Werte für das Client Secret, und klicken Sie auf Schließen.
Um die Anwendung zu aktivieren, klicken Sie auf Aktivieren.
Klicken Sie im Dialogfeld Anwendung aktivieren? auf Anwendung aktivieren.
Eine Erfolgsmeldung wird angezeigt.

OKE-Cluster erstellen

Befolgen Sie die Anweisungen zum Erstellen eines OKE-Clusters, falls noch keines vorhanden ist.
Stellen Sie mit kubectl sicher, dass Sie Zugriff auf das neue Cluster haben. Führen Sie die Schritte im Abschnitt Schnellstart aus, um auf das Cluster zuzugreifen.

Anwendung in OKE-Cluster bereitstellen

So erstellen Sie eine Kubernetes-Deployment-Manifestdatei und stellen die Anwendung in OKE bereit:

Erstellen Sie eine Kubernetes Secret, um alle Konfigurationsparameter für das OKE-Cluster verfügbar zu machen.
1. Richten Sie OCI IAM-Konfigurationsparameter ein.
```
$ 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. Erstellen Sie ein OCI-Registry-Token.
```
$ 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. Der SSL-Schlüssel und das Zertifikat des Load-Balancer-Service sind für die Einrichtung eines HTTPS-Endpunkts für den Zugriff auf die benutzerdefinierte Anwendung mit dem Load Balancer erforderlich. Erstellen Sie ein neues Schlüsselpaar für den Load Balancer.
4. Erstellen Sie ein Kubernetes-Secret, um es für Ihr OKE-Cluster verfügbar zu machen.
```
$ kubectl create secret tls ssl-certificate-secret --key your.key --cert your.crt
```
  Hinweis:
  Oracle empfiehlt, den Load Balancer-Service mit dem SSL-Port einzurichten, es sei denn, er dient Entwicklungs- oder Schnelltests.

Erstellen Sie eine Kubernetes-Deployment-Manifestdatei.

Die Datei enthält eine Podspezifikation für die benutzerdefinierte Anwendung und eine Servicespezifikation für den Load Balancer.

Die Konfigurationsparameter, wie das Token OCIR und die OCI-IAM-Konfiguration, werden als Umgebungsvariablen übergeben, und die Werte werden aus dem Kubernetes-Secret abgerufen, das Sie in den vorherigen Schritten erstellt haben.

Der Pfad des Docker-Containerimages der Anwendung muss der Pfad OCIR zum Image sein.

Im Folgenden finden Sie eine Beispieldatei YAML mit dem Namen 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

Hinweis:

Um den Mandanten-Namespace des aktuellen Mandanten zu ermitteln, öffnen Sie das Menü Profil, und klicken Sie dann auf Mandant:. Der Mandanten-Namespace wird im Feld Object Storage-Namespace angezeigt.

Stellen Sie den benutzerdefinierten Anwendungspod und den Load-Balancer-Service in Ihrem OKE-Cluster bereit.

$ kubectl apply -f ./customlogin.yaml

$ kubectl get all

Name	Bereit	Status	Wird neu gestartet	Age
`pod/login-app`	`1/1`	`Running`	`0`	`12d`

Name	Typ	Cluster-IP	Extern-IP	Port	Age
`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`

Benutzerdefinierte Anmeldeerfahrung testen

Führen Sie die folgenden Schritte aus, um die Anmeldeerfahrung mit der Arbeitsbeispielanwendung zu testen, die Sie für das Testen vorbereitet haben:

Aktualisieren Sie die Beispielanwendung, um die Load Balancer-URL der neu bereitgestellten benutzerdefinierten Anwendung zu verwenden.
Geben Sie in der Beispielanwendung die Load-Balancer-URL in das Feld Benutzerdefinierte Anmelde-URL ein. Bei dieser URL kann es sich je nach DNS-Eintrag um die öffentliche IP-Adresse des Load Balancers oder den FQDN handeln.
Greifen Sie im Browser auf die URL der Beispielanwendung zu.
Sie sollten zur Anwendungsseite für die benutzerdefinierte Anmeldung weitergeleitet werden.