Conecte uma implementação do Cloud Databases a um aplicativo IBM Cloud Kubernetes Service

O repositório de exemplos do "Hello World" do Kubernetes do Cloud Databases contém aplicativos IBM Cloud® de amostra, gravados em várias linguagens de programação, que detalham como conectar uma implementação do Cloud Databases a um aplicativo IBM Cloud Kubernetes Service.

Cada ramificação Git do repositório de exemplos corresponde a amostras em uma determinada linguagem de programação, seja JavaScript, que utiliza Node.js, ou Python. Os arquivos em cada pasta correspondem a um banco de dados ou a uma fila de mensagens.

Testando os aplicativos de amostra

Clone o repositório correspondente a ser utilizado. Por exemplo, é possível clonar o repositório Nó selecionando a ramificação Nó. Em seguida, clique em Clonar ou fazer download para obter a URL que você precisa clonar usando SSH ou HTTPS. Este comando é semelhante a:

git clone -b node git@github.com:IBM-Cloud/clouddatabases-helloworld-kubernetes-examples.git

Ou, clone utilizando HTTPS:

git clone -b node https://github.com/IBM-Cloud/clouddatabases-helloworld-kubernetes-examples.git

Após a clonagem da ramificação, selecione o diretório adequado para o banco de dados com o qual se deseja trabalhar. Cada banco de dados tem a sua própria cópia dessas instruções sobre como provisionar e implementar um banco de dados ou uma fila de mensagens e um aplicativo no IBM Cloud Kubernetes Service.

Executando na IBM Cloud

Caso ainda não tenha uma conta do IBM Cloud, inscreva-se aqui.
Faça download e instale a CLI do IBM Cloud. A ferramenta da CLI do IBM Cloud permite a comunicação com o IBM Cloud a partir do console ou da CLI.

Instale o plug-in da CLI do Kubernetes Service e o plug-in da CLI do Container Registry

ibmcloud plugin install container-service
ibmcloud plugin install container-registry

Para verificar a instalação, execute

ibmcloud plugin list

Você receberá uma resposta como esta:

Listing installed plug-ins...

Plugin Name                            Version   Status
container-registry                     0.1.382
container-service/kubernetes-service   0.3.34

Faça download e instale a CLI do Kubernetes.

Siga as instruções para fazer download e instalar a CLI do Kubernetes para a plataforma utilizada.
Conecte-se ao IBM Cloud na ferramenta da CLI e siga os prompts para efetuar login.
```
ibmcloud login
```
Se você tiver um ID do usuário federado, use o comando ibmcloud login --sso para efetuar login com o seu ID de conexão única.

Criando seu banco de dados

Este processo cria uma instância de banco de dados padrão no serviço especificado e que pode gerar encargos adicionais no plano selecionado.

Para definir um grupo de recursos como destino, utilize o seguinte comando:
```
ibmcloud target -g <RESOURCE_GROUP>
```

Para obter mais informações, consulte Trabalhando com recursos e grupos de recursos (recurso ibmcloud).

O banco de dados pode ser criado a partir da CLI, utilizando o comando ibmcloud resource service-instance-create. O comando leva um nome da instância de serviço, um nome do serviço, um nome do plano e uma localização.
O nome do serviço é um dos Cloud Databases seguintes: databases-for-elasticsearch, databases-for-mongodb, databases-for-postgresql, databases-for-redis, messages-for-rabbitmq, ou databases-for-mysql.
```
ibmcloud resource service-instance-create <INSTANCE_NAME> <SERVICE_NAME> standard <REGION>
```

Lembre-se do nome da instância do banco de dados. Localize o seu identificador de região aqui.

O exemplo anterior provisiona uma instância do Shared Compute. Para obter mais informações, consulte a visão geral dos modelos de hospedagem.

Configurando o app Kubernetes

Crie um Kubernetes Service. Escolha o local e o grupo de recursos no qual deseja configurar o cluster. Selecione o tipo de cluster que você deseja usar. Para este exemplo, é necessário apenas o plano Lite, fornecido com um nó de trabalhador. Após o fornecimento do cluster, você receberá uma lista de etapas a serem executadas para acessar o cluster e configurar as variáveis de ambiente na guia Acesso. Também é possível verificar se a implementação está provisionada e em execução normalmente.
Certifique-se de que tenha como destino o grupo de recursos correto da IBM Cloud de seu Kubernetes Service.

Caso o nome do grupo de recursos seja diferente de default, use o comando a seguir para definir como destino o grupo de recursos do cluster:
```
ibmcloud target -g <RESOURCE_GROUP_NAME>
```
Este exemplo usa o grupo de recursos default.
Crie seu próprio repositório de imagem privada no Container Registry para armazenar a imagem do Docker de seu aplicativo. Como se deseja manter as imagens privadas, é necessário criar um namespace, o que cria uma URL exclusiva para o repositório de imagens.
```
ibmcloud cr namespace-add <YOUR_NAMESPACE>
```
Inclua a implementação do Cloud Databases em seu cluster.
```
ibmcloud ks cluster service bind --cluster <YOUR_CLUSTER_NAME> --namespace default    --service <INSTANCE_NAME_OR_CRN>
```
O namespace "padrão" faz referência à instância do Kubernetes e não ao namespace de armazenamento de imagens criado pelo usuário. Da mesma forma, se o seu banco de dados usar terminais públicos e privados, seu terminal público será usado por padrão. Portanto, para selecionar o terminal privado, primeiro é necessário criar uma chave de serviço para o banco de dados para que o Kubernetes possa usá-la ao ligar-se ao banco de dados. Você configura uma chave de serviço usando o comando:
```
ibmcloud resource service-key-create <YOUR-PRIVATE-KEY> --instance-name    <INSTANCE_NAME_OR_CRN> --service-endpoint private  
```
O terminal de serviço privado é selecionado com --service-endpoint private. Depois disso, o banco de dados é ligado ao cluster Kubernetes por meio do terminal privado, utilizando o comando
```
ibmcloud ks cluster service bind <YOUR_CLUSTER_NAME> default    <INSTANCE_NAME_OR_CRN> --key <YOUR-PRIVATE-KEY>
```
Verifique se o segredo do Kubernetes foi criado em seu namespace do cluster. O Kubernetes usa segredos para armazenar informações confidenciais, como a chave de API do IBM Cloud Identity and Access Management (IAM) e a URL usada pelo contêiner para obter acesso. Execute os comandos a seguir para configurar o cluster como o contexto para esta sessão e, em seguida, obter a chave de API para o acesso à instância de sua implementação
```
ibmcloud ks cluster config --cluster <CLUSTER_NAME_OR_ID>
```
Antes
```
kubectl get secrets --namespace=default
```
Salve o nome do segredo gerado ao ligar your_database_name ao serviço do Kubernetes.
Se você ainda não tiver clonado o app em uma das linguagens disponíveis para o seu ambiente local em seu console, faça isso usando o comando a seguir
```
git clone -b <LANGUAGE> git@github.com:IBM-Cloud/clouddatabases-helloworld-kubernetes-examples.git
```
cd neste diretório recém-criado e cd na pasta de banco de dados. O código para se conectar ao serviço e ler e atualizar o banco de dados pode ser localizado em server.js. Consulte a Estrutura de códigos e os comentários de código para obter informações sobre as funções do app. Um diretório public contém o HTML, as folhas de estilo e o JavaScript do aplicativo da web. No entanto, para que o aplicativo funcione, é necessário, primeiro, enviar por push a imagem do Docker desse aplicativo para o Container Registry.

Construa e envie por push a imagem do Docker do aplicativo para o seu Container Registry. Especifique a região apropriada e dê um nome para o contêiner.

ibmcloud cr build -t <REGION>.icr.io/<NAMESPACE>/<CONTAINER_NAME> .

Para visualizar a imagem no registro de contêiner, é possível utilizar

ibmcloud cr images

Você recebe algo como a resposta a seguir

REPOSITORY                                TAG      DIGEST        NAMESPACE   CREATED       SIZE    SECURITY STATUS
<region>.icr.io/mynamespace/container_name latest   81c3959ea657  mynamespace 4 hours ago   28 MB   No Issues

Atualize o arquivo de configuração de implementação do Kubernetes clouddb-deployment.yaml.

Mude o nome de image para o nome do repositório que você obteve na etapa anterior:
```
image: "<REGION>.icr.io/mynamespace/<container_name>" # Edit me
```
Agora, em secretKeyRef, altere o nome do <db-secret-name> para que corresponda ao nome do segredo que foi criado ao ligar a implementação de banco de dados ao cluster Kubernetes.
```
secretKeyRef:
   name: <DB-SECRET-NAME> # Edit me
```
Em relação à configuração do service no final do arquivo, nodePort indica a porta a partir da qual o aplicativo pode ser acessado. Você tem portas no intervalo de 30000 a 32767 que podem ser usadas, mas escolhemos a 30081. A porta TCP é definida como 8080, que é a porta na qual o aplicativo Node.js é executado no contêiner.

Implementando seu app Kubernetes

Implemente o aplicativo no Kubernetes Service. Ao implementar o aplicativo, ele é automaticamente ligado ao seu cluster Kubernetes.
```
kubectl apply -f clouddb-deployment.yaml
```
Obtenha o IP para o aplicativo.
```
ibmcloud ks workers -c <CLUSTER_NAME>
```
O resultado é algo como:
```
ID                                                 Public IP        PrivateIP      Machine Type   State    Status   Zone    Version
kube-hou02-pa1a59e9fd92f44af9b4147a27a31db5c4-w1   199.199.99.999   10.76202.188   free           normal   Ready    hou02   1.10.11_1536
```
Agora, é possível acessar o aplicativo por meio do IP público na porta 30082.

O aplicativo clouddatabases-helloworld exibe o conteúdo de um banco de dados de exemplos. Para demonstrar que o app está conectado ao seu serviço, inclua algumas palavras no banco de dados. As palavras são exibidas à medida que você as inclui, com as palavras incluídas mais recentemente exibidas primeiro.

Estrutura do código

Estrutura do código
Arquivo	Descrição
server.js	Estabelece uma conexão com o banco de dados, utilizando credenciais de BINDING (o nome criado no arquivo de implementação do Kubernetes para exibição das credenciais) e manipula as operações de criação e de leitura no banco de dados.
main.js	Manipula a entrada do usuário para um comando PUT e analisa os resultados de um comando GET para a saída dos conteúdos do banco de dados.

O app usa uma operação PUT e uma GET:

PUT
- Obtém a entrada do usuário de main.js.
- Inclui a entrada do usuário no banco de dados.
GET
- Recupera os conteúdos do banco de dados.
- Retorna a resposta do comando do banco de dados para main.js.