In qualità di amministratore o sviluppatore di vRealize Automation Code Stream, è possibile utilizzare vRealize Automation Code Stream e VMware Tanzu Kubernetes Grid Integrated Edition (in precedenza denominato VMware Enterprise PKS) per automatizzare la distribuzione delle applicazioni software in un cluster Kubernetes. Questo caso d'uso menziona altri metodi che è possibile utilizzare per automatizzare il rilascio dell'applicazione.

In questo caso d'uso verrà creata una pipeline che include due fasi e si utilizzerà Jenkins per creare e distribuire l'applicazione.

  • La prima fase è per lo sviluppo. Si utilizza Jenkins per estrarre il codice da un ramo nel repository GitHub, quindi lo si crea, lo si testa e lo si pubblica.
  • La seconda fase è per la distribuzione. Esegue un'attività operazione utente che richiede l'approvazione da parte degli utenti chiave per consentire alla pipeline di distribuire l'applicazione nel cluster Kubernetes.
Il workflow che distribuisce un'applicazione in un cluster Kubernetes utilizza Jenkins, Code Stream, GitHub, il trigger per Git e Kubernetes.

Affinché una pipeline possa creare, testare, pubblicare e distribuire l'applicazione, devono essere disponibili gli strumenti di sviluppo, le istanze di distribuzione e il file YAML della pipeline. La pipeline distribuirà l'applicazione nelle istanze di sviluppo e produzione dei cluster Kubernetes in AWS.

Il workflow consente di navigare nel processo che rilascia un'applicazione in un cluster Kubernetes.

Altri metodi che automatizzano il rilascio dell'applicazione:

  • Anziché creare l'applicazione utilizzando Jenkins, è possibile utilizzare la funzionalità di creazione nativa di vRealize Automation Code Stream e un host di creazione Docker.
  • Anziché distribuire l'applicazione in un cluster Kubernetes, è possibile distribuirla in un cluster Amazon Web Services (AWS).

Per ulteriori informazioni sull'utilizzo della funzionalità di creazione nativa di vRealize Automation Code Stream e di un host Docker, vedere:

Prerequisiti

  • Verificare che il codice dell'applicazione da distribuire si trovi in un repository GitHub funzionante.
  • Verificare di disporre di un'istanza di Jenkins funzionante.
  • Verificare di disporre di un server e-mail funzionante.
  • In vRealize Automation Code Stream creare un endpoint e-mail che si connetta al server e-mail.
  • Configurare due cluster Kubernetes in Amazon Web Services (AWS), per lo sviluppo e la produzione, in cui la pipeline distribuirà l'applicazione.
  • Verificare che il repository GitHub contenga il codice YAML per la propria pipeline e, in alternativa, un file YAML che definisca i metadati e le specifiche per l'ambiente in uso.

Procedura

  1. In vRealize Automation Code Stream fare clic su Endpoint > Nuovo endpoint e creare un endpoint Jenkins da utilizzare nella pipeline per estrarre il codice dal repository GitHub.
  2. Per creare endpoint Kubernetes, fare clic su Nuovo endpoint.
    1. Creare un endpoint per il cluster Kubernetes di sviluppo.
    2. Creare un endpoint per il cluster Kubernetes di produzione.
      L'URL del cluster Kubernetes utilizza questo formato e potrebbe o meno includere un numero di porta: http://kubernetes_server_address/api/v1/namespaces/namespace_name/services/https:service_name:%5Bport_name%5D.
      Ad esempio, https://10.111.222.333:6443 o https://api.kubernetesserver.fa2c1d78-9f00-4e30-8268-4ab81862080d.k8s-user.com.
  3. Creare una pipeline che distribuisca un contenitore dell'applicazione, ad esempio Wordpress, nel cluster Kubernetes di sviluppo e impostare le proprietà di input per la pipeline.
    1. Per consentire alla pipeline di riconoscere un commit di codice in GitHub che attiva la pipeline, nella pipeline fare clic sulla scheda Input e selezionare Immetti automaticamente proprietà.
    2. Aggiungere la proprietà denominata GIT_COMMIT_ID e fare clic sulla stella relativa a tale proprietà.
      Quando la pipeline viene eseguita, l'esecuzione visualizza l'ID commit restituito dal trigger Git.
    In una pipeline che utilizza Jenkins e Kubernetes, nella scheda Input vengono visualizzate le proprietà di input Git.
  4. Aggiungere notifiche per l'invio di un'e-mail quando la pipeline viene eseguita correttamente o non riesce.
    1. Nella pipeline fare clic sulla scheda Notifiche, quindi su Aggiungi.
    2. Per aggiungere una notifica email al termine dell'esecuzione della pipeline, selezionare Email e quindi Completamento. Quindi, selezionare il server e-mail, immettere gli indirizzi e-mail e fare clic su Salva.
    3. Per aggiungere un'altra notifica email da inviare quando si verifica un errore della pipeline, selezionare Non riuscito e fare clic su Salva.
    Quando si aggiunge una notifica email, è possibile selezionare uno degli stati della pipeline e quindi il server e i destinatari.
  5. Aggiungere una fase di sviluppo alla pipeline e aggiungere attività che creano, testano e pubblicano l'applicazione. Quindi, convalidare ogni attività.
    1. Per creare l'applicazione, aggiungere un'attività Jenkins che utilizzi l'endpoint Jenkins ed esegua un processo di creazione dal server Jenkins. Per consentire alla pipeline di estrarre il codice, immettere il ramo Git nel formato: ${input.GIT_BRANCH_NAME}
    2. Per testare l'applicazione, aggiungere un'attività Jenkins che utilizzi lo stesso endpoint Jenkins ed esegua un processo di test dal server Jenkins. Immettere lo stesso ramo Git.
    3. Per pubblicare l'applicazione, aggiungere un'attività Jenkins che utilizzi lo stesso endpoint Jenkins, quindi eseguire un processo di pubblicazione dal server Jenkins. Immettere lo stesso ramo Git.
    In una pipeline che utilizza Jenkins e Kubernetes, l'attività Jenkins che crea l'applicazione utilizza l'endpoint Jenkins, il processo Jenkins e il nome del ramo.
  6. Aggiungere una fase di distribuzione alla pipeline, quindi aggiungere un'attività che richiede un'approvazione per la distribuzione dell'applicazione e un'altra attività che distribuisce l'applicazione nel cluster Kubernetes. Quindi, convalidare ogni attività.
    1. Per richiedere un'approvazione per la distribuzione dell'applicazione, aggiungere un'attività operazione utente, aggiungere gli indirizzi e-mail degli utenti che devono approvarla e immettere un messaggio. Quindi, abilitare Invia email.
    2. Per distribuire l'applicazione, aggiungere un'attività Kubernetes. Quindi, nelle proprietà dell'attività Kubernetes, selezionare il cluster Kubernetes di sviluppo, selezionare l'azione Crea e selezionare l'origine payload Definizione locale. Selezionare il file YAML locale.
  7. Aggiungere un webhook Git che consenta a vRealize Automation Code Stream di utilizzare il trigger Git, che attiva la pipeline quando gli sviluppatori eseguono il commit del proprio codice.
    Nel webook per Git che attiva la pipeline Kubernetes, è necessario immettere il ramo e un token segreto.
  8. Per eseguire il test della pipeline, passare al repository GitHub, aggiornare il file YAML dell'applicazione e confermare la modifica.
    1. In vRealize Automation Code Stream verificare che il commit venga visualizzato.
    1. Fare clic su Trigger > Git > Attività.
    2. Cercare il trigger della pipeline.
    3. Fare clic su Dashboard > Dashboard della pipeline.
    4. Nel dashboard della pipeline individuare GIT_COMMIT_ID nell'area della modifica riuscita più recente.
  9. Controllare il codice della pipeline e verificare che la modifica venga visualizzata.

risultati

Congratulazioni! È stata automatizzata la distribuzione dell'applicazione software al cluster Kubernetes.

Esempio: YAML della pipeline di esempio che distribuisce un'applicazione in un cluster Kubernetes

Per il tipo di pipeline utilizzato in questo esempio, YAML è simile al seguente codice:

apiVersion: v1
kind: Namespace
metadata:
  name: ${input.GIT_BRANCH_NAME}
  namespace: ${input.GIT_BRANCH_NAME}
---  
apiVersion: v1
data:
  .dockercfg: eyJzeW1waG9ueS10YW5nby1iZXRhMi5qZnJvZy5pbyI6eyJ1c2VybmFtZSI6InRhbmdvLWJldGEyIiwicGFzc3dvcmQiOiJhRGstcmVOLW1UQi1IejciLCJlbWFpbCI6InRhbmdvLWJldGEyQHZtd2FyZS5jb20iLCJhdXRoIjoiZEdGdVoyOHRZbVYwWVRJNllVUnJMWEpsVGkxdFZFSXRTSG8zIn19
kind: Secret
metadata:
  name: jfrog
  namespace: ${input.GIT_BRANCH_NAME}
type: kubernetes.io/dockercfg
---   
apiVersion: v1
kind: Service
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  ports:
    - port: 80
  selector:
    app: codestream
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  selector:
    matchLabels:
      app: codestream
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: codestream
        tier: frontend
    spec:
      containers:
      - name: codestream
        image: cas.jfrog.io/codestream:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: codestream
      imagePullSecrets:
      - name: jfrog
      

Operazioni successive

Per distribuire l'applicazione software al cluster Kubernetes di produzione, eseguire di nuovo i passaggi e selezionare il cluster di produzione.

Per ulteriori informazioni sull'integrazione di vRealize Automation Code Stream con Jenkins, vedere Come integrare vRealize Automation Code Stream con Jenkins.