Distribuisci applicazione di accesso in OKE

Scaricare il codice da GitHub, personalizzarlo e distribuirlo.

Il codice di esempio è disponibile sul sito GitHub.

Passare a GitHub.
Duplicare o scaricare il repository.
Seguire le istruzioni riportate nel documento README.

Per distribuire l'applicazione in OKE, procedere come segue.

Eseguire il fork e duplicare il repository GitHub.
Creare il Dockerfile e creare un'immagine.
Eseguire il push dell'immagine Docker nel registro OCI.
Impostare le variabili di ambiente.
Registrare l'applicazione nel dominio di Identity.
Distribuire l'immagine Docker in un cluster OKE.
Testare l'esperienza di accesso personalizzata con l'applicazione di esempio di lavoro.

Forcella e copia repository GitHub

Eseguire il fork del repository GitHub per creare una copia di un repository sul computer di sviluppo.

Quindi clonare il repository biforcato sul computer di sviluppo utilizzando il comando seguente.

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

Crea un Dockerfile

Creare un nuovo file Dockerfile nel repository duplicato.

L'applicazione di accesso personalizzata è un'applicazione Node JS. Il Dockerfile è simile a qualsiasi applicazione Node JS.

Utilizzare il seguente Dockerfile di esempio come punto di partenza.

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

È possibile utilizzare la distribuzione Linux consentita nell'organizzazione anziché alpine.

Crea un'immagine Docker

Utilizzare il comando seguente per creare un'immagine Docker dal Dockerfile e fornire il nome dell'immagine.

docker build -t $IMAGE_NAME $PATH_TO_DOCKERFILE

Utilizzare il comando seguente per elencare le immagini per verificare l'immagine Docker.

docker images

Esegui il push dell'immagine Docker nel registro OCI

Per eseguire il push dell'immagine Docker nel registro OCI, attenersi alla procedura riportata di seguito.

Collegarsi a OCI Console.
Aprire il menu Profilo e fare clic su Impostazioni utente per visualizzare i dettagli.
Nella pagina Token di autenticazione fare clic su Genera token per creare un nuovo token.

Attenzione
Copiare il token di autenticazione e salvarlo in una posizione sicura per recuperarlo in un secondo momento. Impossibile visualizzare il token di autenticazione in un secondo momento nella console.
Chiudere la finestra di dialogo Genera token.
Eseguire il comando docker login <region-key>.ocir.io per collegarsi a OCI Registry (OCIR). Ad esempio, per l'area Ashburn eseguire docker login iad.ocir.io.

Immettere il nome utente con il token di autenticazione in questo formato se l'utente si trova nel dominio predefinito <tenancy-namespace>/<username>.

Per l'utente del dominio IAM non predefinito, utilizzare il formato <tenancy-namespace>/<domain_name>/<username>.

Quando viene richiesta la password, immettere il token di autenticazione Oracle Cloud Infrastructure dell'utente.
Contrassegnare e inviare a OCIR l'immagine docker creata nel passo precedente.
È possibile creare un nuovo repository nel registro container OCI o utilizzarne uno esistente. Il formato del tag deve essere <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
```
Il file manifesto Kubernetes utilizzerà questa immagine durante la distribuzione di un pod.
In alternativa, puoi seguire queste istruzioni dettagliate per spingere l'immagine Docker nel registro OCI.

L'immagine Docker viene estratta nel registro OCI e pronta per la distribuzione.

Impostazione delle variabili di ambiente

Obbligatorio: IDCS_CLIENT_ID, IDCS_CLIENT_ID e IDCS_SECRET
Facoltativo: IDCS_SELFREGPROFILES per passare un profilo di autoregistrazione all'applicazione di accesso e DEBUG_LOGIN=true per abilitare il log di debug in NodeJS
Produzione: NODE_ENV=variabile di produzione

Utilizzare i segreti Kubernetes per memorizzare questi valori e passarli nel file manifesto.

Registrare l'applicazione

Registrare un'applicazione di credenziali client in IDCS o nel dominio di Identity in modo che l'applicazione di collegamento personalizzata possa effettuare chiamate all'API REST di autenticazione di Oracle Identity Cloud Service e consentire agli utenti di collegarsi.

Nella console di Oracle Identity Cloud Service espandere il cassetto di navigazione, quindi fare clic su Applicazioni.
Nella pagina Applicazioni, fare clic su Aggiungi.
Nella finestra di dialogo Aggiungi applicazione fare clic su applicazione sicura o applicazione riservata.
Nel riquadro Dettagli immettere i valori riportati di seguito.
- Nome: Applicazione di accesso personale
- Descrizione: Applicazione di accesso personale
Fare clic su Avanti.
Nel riquadro Client, selezionare Configura applicazione come client ora, quindi selezionare Credenziali client come Tipi di privilegi consentiti.
Nel riquadro Client, scorrere verso il basso e fare clic su Aggiungi dopo Concedere l'accesso client alle API di amministrazione di Identity Cloud Service.
Nella finestra di dialogo Aggiungi ruolo applicazione, selezionare Accedi, Verifica e-mail, Reimposta password, Password dimenticata e Registrazione automatica nella lista, quindi fare clic su Aggiungi.
Fare clic su Avanti nel riquadro Client e nei riquadri seguenti finché non si raggiunge l'ultimo riquadro.
Fare clic su Fine.
Nella finestra di dialogo Applicazione aggiunta, annotare i valori ID client e Segreto client, quindi fare clic su Chiudi.
Per attivare l'applicazione, fare clic su Attiva.
Nella finestra di dialogo Attiva applicazione?, fare clic su Attiva applicazione.
Viene visualizzato un messaggio di operazione riuscita.

Creare un cluster OKE

Se non si dispone già di un cluster OKE, seguire le istruzioni per crearne uno.
Assicurarsi di avere accesso al nuovo cluster utilizzando kubectl. Seguire i passi della sezione Avvio rapido per accedere al cluster.

Distribuisci applicazione nel cluster OKE

Per creare un file manifest di distribuzione Kubernetes e distribuire l'applicazione in OKE, effettuare le operazioni riportate di seguito.

Creare un valore Kubernetes Secret per rendere disponibili tutti i parametri di configurazione per il cluster OKE.
1. Impostare i parametri di configurazione IAM 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. Creare un token OCI Registry.
```
$ 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 chiave e il certificato SSL del servizio load balancer sono necessari per impostare un endpoint HTTPS per l'accesso all'applicazione personalizzata mediante il load balancer. Creare una nuova coppia di chiavi per il load balancer.
4. Creare un segreto Kubernetes per renderlo disponibile per il cluster OKE.
```
$ kubectl create secret tls ssl-certificate-secret --key your.key --cert your.crt
```
  Nota
  Oracle consiglia di impostare il servizio load balancer con la porta SSL a meno che non sia destinato allo sviluppo o a test rapidi.

Creare un file manifest di distribuzione Kubernetes.

Il file contiene una specifica pod per l'applicazione personalizzata e una specifica servizio per il load balancer.

I parametri di configurazione quali il token OCIR e la configurazione IAM OCI vengono passati come variabili di ambiente e i valori vengono prelevati dal segreto Kubernetes creato nei passi precedenti.

Il percorso dell'immagine del contenitore Docker dell'applicazione deve essere il percorso OCIR dell'immagine.

Di seguito è riportato un file YAML di esempio denominato 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

Nota

Per trovare lo spazio di nomi della tenancy corrente, aprire il menu Profilo e fare clic su Tenancy:. Lo spazio di nomi della tenancy viene visualizzato nel campo Spazio di nomi dello storage degli oggetti.

Distribuire il pod dell'applicazione personalizzata e il servizio del load balancer nel cluster OKE.

$ kubectl apply -f ./customlogin.yaml

$ kubectl get all

Nome	Pronto	Stato	Riavvia	Età
`pod/login-app`	`1/1`	`Running`	`0`	`12d`

Nome	Type	Cluster-IP	IP esterno	Porta(s)	Età
`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`

Test dell'esperienza di accesso personalizzata

Attenersi alla procedura riportata di seguito per eseguire il test dell'esperienza di accesso utilizzando l'applicazione di esempio di lavoro preparata per il test.

Aggiornare l'applicazione di esempio per utilizzare l'URL del load balancer dell'applicazione personalizzata appena distribuita.
Nell'applicazione di esempio immettere l'URL del load balancer nel campo URL di login personalizzato. Questo URL può essere l'indirizzo IP pubblico del load balancer o il nome FQDN in base alla voce DNS.
Accedere all'URL dell'applicazione di esempio nel browser.
Andare alla pagina dell'applicazione di accesso personalizzata.