Implantar Aplicativo de Acesso no OKE

Faça download do código em GitHub, personalize o código e implante-o.

O código de amostra está disponível em GitHub.

Vá para GitHub.
Clone ou faça download do repositório.
Siga as instruções no documento README.

Siga estas etapas para implantar o aplicativo no OKE:

Forque e clone o repositório GitHub.
Crie o Dockerfile e crie uma imagem.
Envie a imagem do Docker ao OCI Registry.
Definir variáveis de ambiente.
Registre o aplicativo em seu Domínio de Identidades.
Implantar a imagem do Docker em um cluster do OKE.
Teste a experiência de conexão personalizada com seu aplicativo de amostra de trabalho.

Repositório Fork e Clone GitHub

Forque o repositório GitHub para criar uma cópia de um repositório na sua máquina de desenvolvimento.

Em seguida, clone o repositório bifurcado em sua máquina de desenvolvimento usando o comando a seguir.

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

Criar um Dockerfile

Crie um novo Dockerfile de nomes de arquivo no repositório clonado.

O aplicativo de acesso personalizado é um aplicativo Node JS. O Dockerfile é semelhante a qualquer aplicativo Node JS.

Use o Dockerfile de amostra a seguir como ponto de partida.

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

Você pode usar a distribuição do Linux permitida em sua organização em vez de alpine.

Criar uma Imagem Docker

Use o comando a seguir para criar uma imagem do Docker com base no Dockerfile e fornecer o nome da sua imagem.

docker build -t $IMAGE_NAME $PATH_TO_DOCKERFILE

Use o comando a seguir para listar as imagens para verificar sua imagem do Docker.

docker images

Enviar a Imagem do Docker ao OCI Registry

Para enviar sua imagem do Docker ao OCI Registry, siga estas etapas:

Acesse a Console do OCI.
Abra o menu Perfil e clique em Definições do Usuário para exibir os detalhes.
Na página Tokens de Autenticação, clique em Gerar Token para criar um novo token.

Atenção:
Copie o token de autenticação e salve-o em um local seguro para recuperá-lo posteriormente. Você não pode ver o token de autenticação posteriormente na Console.
Feche a caixa de diálogo Gerar Token.
Execute o comando docker login <region-key>.ocir.io para acessar o OCI Registry (OCIR). Por exemplo, para a região Ashburn, execute docker login iad.ocir.io.

Informe o nome de usuário com o token de autenticação neste formato se o usuário estiver no domínio padrão <tenancy-namespace>/<username>.

Para o usuário do domínio do IAM não padrão, use o formato <tenancy-namespace>/<domain_name>/<username>.

Quando a senha for solicitada, insira o token de autenticação do Oracle Cloud Infrastructure do usuário.
Marque e envie a imagem do docker criada na etapa anterior para o OCIR.
Você pode criar um novo repositório no registro de contêiner do OCI ou usar um existente. O formato da tag deve ser <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
```
O arquivo de manifesto do Kubernetes usará essa imagem ao implantar um pod.
Como alternativa, você pode seguir estas instruções detalhadas para enviar sua imagem do Docker ao OCI Registry.

A imagem do Docker é extraída para o OCI Registry e pronta para implantação.

Configurar Variáveis de Ambiente

Obrigatório: IDCS_CLIENT_ID, IDCS_CLIENT_ID e IDCS_SECRET
Opcional: IDCS_SELFREGPROFILES para informar um perfil de autorregistro ao aplicativo de acesso e DEBUG_LOGIN=true para ativar o log de depuração em NodeJS
Produção: NODE_ENV=variável de produção

Use Segredos do Kubernetes para armazenar esses valores e transmiti-los no arquivo de manifesto.

Registrar o Aplicativo

Registre um aplicativo de credenciais do cliente no IDCS ou no Domínio de Identidades para que o aplicativo de acesso personalizado possa fazer chamadas para a API REST de Autenticação do Oracle Identity Cloud Service e permitir que os usuários acessem.

Na console do Oracle Identity Cloud Service, expanda a Gaveta de Navegação e, em seguida, clique em Aplicativos.
Na página Aplicativos, clique em Adicionar.
Na caixa de diálogo Adicionar Aplicativo, clique em Aplicativo Confiável ou Aplicativo Confidencial.
No painel Detalhes, informe os seguintes valores:
- Nome: Meu Aplicativo de Acesso
- Descrição: Meu Aplicativo de Acesso
Clique em Próximo.
No painel Cliente, selecione Configurar este aplicativo como cliente agora e, em seguida, selecione Credenciais do Cliente como Tipos de Concessão Permitidos.
No painel Cliente, role para baixo e clique em Adicionar após Conceder ao cliente acesso às APIs de Administração do Identity Cloud Service.
Na caixa de diálogo Adicionar Atribuição de Aplicativo, selecione Acessar, Verificar E-mail, Redefinir Senha, Esqueceu a Senha e Registro Automático na lista e clique em Adicionar.
Clique em Próximo no painel Cliente e nos painéis a seguir até chegar ao último painel.
Clique em Concluir.
Na caixa de diálogo Application Added, anote os valores Client ID e Client Secret e, em seguida, clique em Close.
Para ativar o aplicativo, clique em Ativar.
Na caixa de diálogo Ativar Aplicativo?, clique em Ativar Aplicativo.
Uma mensagem de sucesso é exibida.

Criar um Cluster do OKE

Siga as instruções para criar um cluster do OKE, se você ainda não tiver um.
Certifique-se de ter acesso ao novo cluster usando kubectl. Siga as etapas da seção Início Rápido para acessar seu cluster.

Implantação de Aplicativo em um Cluster do OKE

Para criar um arquivo de manifesto de implantação do Kubernetes e implantar o aplicativo no OKE, siga estas etapas:

Crie um Kubernetes Secret para disponibilizar todos os parâmetros de configuração ao cluster do OKE.
1. Configurar parâmetros de configuração do OCI IAM.
```
$ 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. Crie um token de registro do 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. A chave e o certificado SSL do serviço do balanceador de carga são necessários para configurar um ponto final HTTPS para acessar o aplicativo personalizado usando o balanceador de carga. Crie um novo par de chaves para seu balanceador de carga.
4. Crie um segredo do Kubernetes para disponibilizá-lo ao cluster do OKE.
```
$ kubectl create secret tls ssl-certificate-secret --key your.key --cert your.crt
```
  Observação:
  A Oracle recomenda que você configure o serviço do balanceador de carga com a porta SSL, a menos que seja para fins de desenvolvimento ou teste rápido.

Crie um arquivo de manifesto de implantação do Kubernetes.

O arquivo contém uma especificação de pod para o aplicativo personalizado e uma especificação de serviço para o balanceador de carga.

Os parâmetros de configuração, como o token OCIR e a configuração do OCI IAM, são passados como variáveis de ambiente e os valores são coletados do Segredo do Kubernetes criado nas etapas anteriores.

O caminho da imagem do contêiner do Docker do aplicativo deve ser o caminho OCIR para a imagem.

Veja a seguir um arquivo de amostra YAML chamado 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

Observação:

Para descobrir o Namespace da Tenancy atual, abra o menu Perfil e clique em Tenancy:. O namespace da tenancy é exibido no campo Namespace do Serviço Object Storage.

Implante o pod de aplicativo personalizado e o serviço do balanceador de carga no cluster do OKE.

$ kubectl apply -f ./customlogin.yaml

$ kubectl get all

Nome	Pronto	Status	Reinicializações	Idade
`pod/login-app`	`1/1`	`Running`	`0`	`12d`

Nome	Tipo	Cluster-IP	IP Externo	Porta(s)	Idade
`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`

Teste a Experiência de Acesso Personalizado

Siga estas etapas para testar a experiência de acesso usando o aplicativo de amostra de trabalho preparado para teste:

Atualize o aplicativo de amostra para usar o URL do balanceador de carga do aplicativo personalizado recém-implantado.
Em seu aplicativo de amostra, informe o URL do balanceador de carga no campo URL de Log-in Personalizado. Esse URL pode ser o endereço IP público do balanceador de carga ou o FQDN com base na sua entrada de DNS.
Acesse o URL do aplicativo de amostra no navegador.
Você deverá ser levado à página do aplicativo de acesso personalizado.