Come Eseguire un’Installazione di MongoDB su Kubernetes

Il rilascio delle applicazioni in Kubernetes può essere impegnativo, specialmente per le applicazioni stateful come MongoDB nel cluster Kubernetes. Come facilitare il rilascio? Lascia che l’operatore Kubernetes di MongoDB gestisca automaticamente il rilascio e la gestione delle applicazioni stateful all’interno del tuo cluster Kubernetes.

In questo tutorial, imparerai come rilasciare MongoDB su Kubernetes utilizzando l’operatore Kubernetes di MongoDB.

Continua a leggere e inizia ad automatizzare i tuoi rilasci Kubernetes!

Prerequisiti

Questo tutorial sarà una dimostrazione pratica. Per seguirla, assicurati di avere i seguenti requisiti:

  • A Kubernetes cluster – This demo uses the Kubernetes cluster v1.23.
  • Kubectl installato sulla macchina locale.
  • Git installato sulla tua macchina.
  • jq Parser JSON installato sulla macchina locale.

Creazione di un namespace per MongoDB

Quando si distribuiscono applicazioni su Kubernetes, è sempre consigliabile creare un namespace specifico per i propri progetti.

I namespace semplificano la gestione delle risorse di Kubernetes per gli amministratori e prevengono collisioni di nomi. Allo stesso tempo, la creazione di namespace impedisce un utilizzo errato delle risorse nell’ambiente Kubernetes.

Apri il tuo terminale e esegui il comando kubectl create sottostante per creare un nuovo namespace (ns) chiamato mongodb nel tuo cluster Kubernetes.

kubectl create ns mongodb

Ora esegui il comando kubectl get sottostante per verificare l’elenco dei namespace nel tuo cluster Kubernetes.

kubectl get ns

Vedrai un nuovo namespace chiamato mongodb disponibile nel tuo cluster, come mostrato di seguito.

Creating and Verifying the mongodb Namespace

Scaricamento dell’operatore Kubernetes MongoDB

Dopo aver creato uno spazio dei nomi, è ora di scaricare l’operatore Kubernetes di MongoDB. L’operatore Kubernetes di MongoDB è un insieme di operatori Kubernetes. Questi operatori Kubernetes offrono il deployment, la configurazione e la gestione automatica di MongoDB Community nell’ambiente Kubernetes.

Esegui il comando git sottostante per clonare il progetto dell’operatore Kubernetes di MongoDB sul tuo computer locale.

git clone <https://github.com/mongodb/mongodb-kubernetes-operator.git>

Ora esegui ciascun comando qui sotto per cambiare la tua directory di lavoro corrente a mongodb-kubernetes-operator e elencare (ls) tutti i file e le directory disponibili.

# Cambia la directory di lavoro in mongodb-kubernetes-operator
cd mongodb-kubernetes-operator/

# Elenca file e directory
ls

Vedrai una sottodirectory chiamata config all’interno del progetto ~/mongodb-kubernetes-operator, come mostrato di seguito. La sottodirectory config contiene esempi di file YAML per il deployment di MongoDB su Kubernetes.

Downloading mongodb-kubernetes-operator Source Code

Deployment dell’operatore MongoDB

Ora che il tuo spazio dei nomi personalizzato e l’operatore Kubernetes di MongoDB sono configurati, sei pronto per deployare l’operatore MongoDB sul tuo cluster Kubernetes. Come? Utilizzerai la configurazione all’interno della directory config.

L’operatore MongoDB gestisce il ciclo di vita del tuo deployment MongoDB sul cluster Kubernetes. L’operatore creerà, gestirà e dimensionerà automaticamente lo stato del tuo deployment MongoDB.

Per distribuire l’operatore MongoDB, è necessario creare una Definizione delle Risorse Personalizzate (CRD) di Kubernetes e il controller. Il CRD di Kubernetes è estensibile all’API di Kubernetes, consentendoti di creare risorse personalizzate in Kubernetes.

1. Esegui il comando kubectl apply di seguito per creare un nuovo CRD di Kubernetes per la distribuzione di MongoDB.

Il operatore Kubernetes ha sostituito ogni interazione umana per distribuire un’applicazione su Kubernetes. L’operatore è un controller di pod che distribuisce e gestisce automaticamente la tua applicazione stateful su Kubernetes.

kubectl apply -f config/crd/bases/mongodbcommunity.mongodb.com_mongodbcommunity.yaml
Creating New Kubernetes CRD MongoDB Kubernetes Deployment

2. Successivamente, esegui il seguente comando kubectl get per verificare l’elenco delle crd disponibili nel tuo Kubernetes.

kubectl get crd/mongodbcommunity.mongodbcommunity.mongodb.com

Di seguito, puoi vedere il CRD con il nome mongodbcommunity.mongodbcommunity.mongodb.org.

Checking List of CRDs

3. Esegui il comando seguente per creare un nuovo controllo degli accessi basato su ruoli (RBAC) personalizzato per l’operatore MongoDB e specifica l’implementazione di RBAC nel namespace mongodb.

Questo comando crea un nuovo ruolo, rolebinding e serviceaccount per l’operatore MongoDB, che sono autorizzazioni personalizzate nel tuo cluster Kubernetes. Queste autorizzazioni personalizzate sono necessarie per il deploy e la gestione automatica di MongoDB.

kubectl apply -k config/rbac/ -n mongodb
Deploying RBAC for MongoDB Deployment

4. Ora, esegui ogni comando kubectl di seguito per verificare il ruolo, rolebinding e serviceaccount per l’operatore MongoDB.

# Verifica elenco dei ruoli
kubectl get role mongodb-kubernetes-operator -n mongodb

# Verifica elenco dei rolebinding
kubectl get rolebinding mongodb-kubernetes-operator -n mongodb

# Verifica serviceaccount
kubectl get serviceaccount mongodb-kubernetes-operator -n mongodb

L’output qui sotto mostra che il ruolo, rolebinding e serviceaccount mongodb-kubernetes-operator sono stati creati nello spazio dei nomi mongodb.

Checking role, rolebinding, and serviceaccount on Kubernetes

5. Una volta completata la verifica, esegui il comando kubectl di seguito per deployare l’operatore MongoDB nello spazio dei nomi mongodb.

Questo comando crea un nuovo pod (mongodb-kubernetes-operator) con l’immagine Docker di base (quay.io/mongodb/mongodb-kubernetes-operator). Questo pod agirà come controller per il deploy automatico di MongoDB ReplicaSets sul cluster Kubernetes.

kubectl create -f config/manager/manager.yaml -n mongodb

Sotto puoi vedere che il deploy dell’operatore MongoDB è stato creato, ma il pod è ancora in fase di inizializzazione.

Deploying MongoDB Operator to the mongodb Namespace

6. Infine, esegui i seguenti comandi per verificare il deploy e i pod nello spazio dei nomi mongodb.

# Verifica deploy nello spazio dei nomi mongodb
kubectl get deployment.apps -n mongodb

# Verifica pod nello spazio dei nomi mongodb
kubectl get pods -n mongodb

Come puoi vedere qui sotto, il pod dell’operatore MongoDB è in esecuzione.

Verifying MongoDB Operator Deployment and Pod

Dispiegamento di ReplicaSet MongoDB su Kubernetes

Dopo aver effettuato il deployment di MongoDB, effettuerai il deployment di ReplicaSet su Kubernetes per garantire l’alta disponibilità e la ridondanza per il tuo deployment di MongoDB. Non vorrai avere tempi di inattività nel tuo deployment.

Il deployment di ReplicaSet MongoDB utilizzando l’Operatore Kubernetes di MongoDB è sicuro per impostazione predefinita utilizzando l’autenticazione SCRAM per gli utenti. Allo stesso tempo, puoi utilizzare una connessione sicura TLS per le connessioni degli utenti e delle applicazioni ed esporre le metriche Prometheus per il monitoraggio delle risorse.

Correlato: Iniziare con il monitoraggio del cluster Kubernetes di Grafana & Prometheus

All’interno della directory config/samples/ vedrai più esempi di file YAML per il deployment di ReplicaSet. Ciascun file può essere utilizzato in diversi scenari di deployment, ma il file di deployment predefinito di ReplicaSet è mongodb.com_v1_mongodbcommunity_cr.yaml.

1. Modifica il file YAML per il tuo deployment utilizzando il tuo editor preferito. In questa demo viene utilizzato il file /mongodb.com_v1_hostpath.yaml per il deployment locale. Questo file YAML si trova nella directory config/samples/arbitrary_statefulset_configuration/.

Se stai distribuendo l’operatore MongoDB Kubernetes sui servizi cloud come GKE e AKS, utilizza il file YAML mongodb.com_v1_mongodbcommunity_cr.yaml. Ma se stai distribuendo localmente dentro Kind o Minikube, puoi utilizzare il file YAML personalizzato (arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml), che crea automaticamente PV e PVC personalizzati per i pod di MongoDB ReplicaSet.

Di seguito, modifica il numero (membri) di ReplicaSets che desideri distribuire a seconda del tuo ambiente, ma il valore predefinito è 3. Per questo tutorial, il numero di ReplicaSets è impostato su 2.

spec:
  members: 2 # Numero di set di repliche da creare
  security:
    authentication:
      modes:
      - SCRAM
  statefulSet:

Sostituisci <la-tua-password-qui> con la tua password forte. Utilizzerai questa password per accedere al database MongoDB e, per impostazione predefinita, utilizzerai l’autenticazione SCRAM.

Salva le modifiche e chiudi l’editor una volta soddisfatto della password.

---
apiVersion: v1
kind: Secret
metadata:
  name: my-user-password
type: Opaque
stringData:
  password: <your-password-here> # Imposta la password per l'amministratore di MongoDB

2. Successivamente, esegui il comando kubectl di seguito per distribuire (apply) il ReplicaSet di MongoDB utilizzando il mongodb.com_v1_hostpath.yaml nello spazio dei nomi mongodb.

Questo comando crea quanto segue:

  • A new custom resource (MongoDBCommunity) with the name mdb0 under the mongodbcommunity.mongodb.com/v1 CRD
  • Secret di Kubernetes per memorizzare le password degli utenti di MongoDB. Allo stesso tempo, alcuni PV e PVC con il tipo come hostPath per il Replica Set di MongoDB.

Il rilascio richiederà del tempo, a seconda delle dimensioni dei ReplicaSets da creare e del cluster Kubernetes stesso.

kubectl apply -f config/samples/arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml -n mongodb
Deploying MongoDB Replica Sets

3. Dopo il rilascio, eseguire ciascun comando di seguito per verificare le risorse personalizzate e i pod nel namespace mongodb.

# Verifica del crd mongodbcommunity
kubectl get mongodbcommunity -n mongodb

# Verifica dei pod nel namespace mongodb
kubectl get pods -n mongodb

L’output sottostante mostra quanto segue:

  • La risorsa personalizzata MongoDBCommunity con il nome mdb0 è in esecuzione con MongoDB v4.4.0.
  • I due pod ReplicaSet di MongoDB sono in esecuzione con i nomi mdb0-0 e mdb0-1. Ogni pod contiene due diversi container, il mongod e il container mongodb-agent.
Verifying MongoDB ReplicaSet Deployment and Pods

4. Infine, eseguire un altro comando kubectl di seguito per verificare il pv e pvc nel namespace mongodb.

kubectl get pv,pvc -n mongodb

L’output sottostante mostra alcuni pv e pvc utilizzati dai pod ReplicaSet di MongoDB.

Checking PV and PVC on the mongodb Namespace

Creazione di un nuovo utente e database per il rilascio di MongoDB

Hai completato il rilascio dell’operatore MongoDB e dei ReplicaSets nel tuo cluster Kubernetes a questo punto. Il passaggio successivo è creare un nuovo database e utente MongoDB per la tua applicazione.

Verrà creato un nuovo secret Kubernetes per il nuovo utente, verrà modificata la risorsa personalizzata del rilascio ReplicaSet e verrà aggiornato il ReplicaSet nel tuo cluster.

1. Crea un nuovo file YAML utilizzando il tuo editor preferito e popola il seguente segreto Kubernetes. Puoi dare il nome che preferisci al file YAML, ma in questo tutorial il file è chiamato new-user.yaml.

Questo file YAML crea un nuovo segreto Kubernetes con il nome “myappdata” e la password “myapppassword”.

---
apiVersion: v1
kind: Secret
metadata:
  name: myappdata # nome del segreto meta.data
type: Opaque
stringData:
  password: myapppassword # password per il nuovo utente

2. Successivamente, esegui il comando kubectl qui sotto per eseguire la configurazione new-user.yaml.

Questo comando crea e applica (apply) un nuovo segreto Kubernetes al tuo cluster e applica questo segreto al namespace “mongodb”.

kubectl apply -f new-user.yaml -n mongodb
Creating Secret to Kubernetes Cluster

3. Modifica il file YAML della configurazione ReplicaSet CRD (mongodb.com_v1_hostpath.yaml) nella directory config/samples/arbitrary_statefulset_configuration

Aggiungi la seguente configurazione al file mongodb.com_v1_hostpath.yaml, che crea il database e l’utente per MongoDB.

Assicurati di sostituire “scram-secret-myapp” con le tue credenziali scram, salva le modifiche al file e chiudi l’editor.

    - name: appuser # Nuovo utente appuser
      db: admin # Consente l'autenticazione al database admin
      passwordSecretRef:
        name: myappdata # Il segreto Kubernetes
      roles:
        - name: dbAdmin # Imposta il ruolo dbAdmin
          db: appdb1 # per l'appdb1
      scramCredentialsSecretName: scram-secret-myapp

4. Ora, esegui il seguente comando per applicare le nuove modifiche apportate al file `mongodb.com_v1_hostpath.yaml` nel passaggio tre.

kubectl apply -f config/samples/arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml -n mongodb
Creating New MongoDB User and Database on Kubernetes

5. Infine, esegui ciascun comando qui sotto per generare le connessioni dettagliate di MongoDB per la tua applicazione. Questi comandi generano la connessione dettagliata di MongoDB per le tue applicazioni in output JSON e analizzano l’output usando il comando linea di comando `jq`.

Sostituisci mdb0-admin-mongoadmin con i dettagli del tuo ambiente come segue:

  • mdb0 – Il nome dei metadati delle risorse MongoDB.
  • admin – Il database da autenticare.
  • mongoadmin – L’utente che utilizzerai per autenticarti
# Recupera i dettagli dell'autenticazione e le connessioni dell'amministratore
kubectl get secrets mdb0-admin-mongoadmin -n mongodb -o json | jq -r '.data | with_entries(.value |= @base64d)'

# Recupera i dettagli dell'autenticazione dell'appuser e le connessioni
kubectl get secrets mdb0-admin-appuser -n mongodb -o json | jq -r '.data | with_entries(.value |= @base64d)'

L’output qui sotto ti mostra come connetterti a MongoDB utilizzando le connessioni standard e standardSrv. Vedrai anche lo username e la password del tuo deployment MongoDB.

Retrieving Details of MongoDB User and Password, and Connections

Connessione al Deployment MongoDB

Hai completato il deployment di MongoDB sul cluster Kubernetes usando l’operatore Kubernetes di MongoDB. Ma come puoi sapere se il deployment funziona? Verificherai la connessione al database e all’utente della tua macchina locale a MongoDB all’interno del cluster Kubernetes.

Per verificare la connessione al tuo deployment MongoDB, utilizzerai il port-forwarding. Il port-forwarding in Kubernetes ti permette di creare una porta di inoltro da qualsiasi servizio Kubernetes alla tua porta locale.

1. Esegui il comando kubectl di seguito per ottenere l’elenco dei servizi (svc) nello spazio dei nomi mongodb (-n).

kubectl get svc -n mongodb

Di seguito, vedrai il servizio chiamato mdb0-svc, che espone la porta 27017 (porta predefinita di MongoDB).

Listing Services on the mongodb Namespace

2. Successivamente, esegui il comando sottostante per creare l’inoltro di porta verso il cluster Kubernetes.

Questo comando crea un nuovo inoltro di porta sul servizio Kubernetes (mdb0-svc) e inoltra la porta locale 27017 alla porta del servizio Kubernetes 27017.

kubectl port-forward service/mdb0-svc -n mongodb 27017:27017
Setting up Port-forward

3. Infine, apri l’applicazione MongoDB Compass sul tuo computer locale, aggiungi una nuova connessione con il seguente formato e clicca Connetti per connetterti a MongoDB.

Cambia i campi nome utente e password con quelli del tuo utente e password di MongoDB.

# Connettersi come mongoadmin
mongodb://mongoadmin:secretpassword@localhost:27017/admin?ssl=false

# Connettersi come appuser
mongodb://appuser:myapppassword@localhost:27017/admin?ssl=false
Connecting as mongoadmin user to MongoDB
Connecting as appuser to MongoDB

Quando la connessione avviene con successo, otterrai la seguente finestra che conferma che il deployment di MongoDB su Kubernetes sta funzionando correttamente.

Per l’utente mongoadmin, vedrai i database predefiniti (local, config e admin).

Verifying Connection to the MongoDB mongoadmin

Per l’appuser, vedrai solo un database di privilegi chiamato appdb1.

Verifying Connection to the MongoDB as appuser

Conclusioni

Con questa guida, hai imparato come distribuire MongoDB nel cluster Kubernetes utilizzando l’operatore Kubernetes di MongoDB. Hai anche toccato l’uso di base dell’operatore Kubernetes. E a questo punto, hai già una solida conoscenza su come distribuire e gestire automaticamente le applicazioni su Kubernetes.

Perché non configurare una connessione TLS sulla tua distribuzione di MongoDB per sfruttare questa nuova conoscenza? La connessione TLS protegge le connessioni tra i set di repliche e protegge le connessioni del client o dell’applicazione a MongoDB.

Source:
https://adamtheautomator.com/mongodb-kubernetes/