Accelera lo sviluppo in Cloud Code per Cloud Shell

Per velocizzare lo sviluppo locale in Cloud Code per Cloud Shell, sfrutta la sincronizzazione file e il ricaricamento a caldo, il deployment automatico al salvataggio e utilizza i moduli Skaffold per sviluppare parti di un'applicazione separatamente.

Attiva la sincronizzazione dei file Skaffold e il ricaricamento a caldo

Per migliorare l'efficienza del flusso di lavoro di sviluppo locale ed evitare di dover ricreare, eseguire nuovamente il deployment e riavviare i pod, Skaffold supporta la copia dei file modificati in un container di cui è stato eseguito il deployment. Ciò significa che quando apporti modifiche ai file di codice statici e sorgente, puoi vedere le modifiche applicate in pochi secondi, con un ciclo di feedback accelerato.

Per i file statici (come i file HTML e CSS), questo comportamento di copia è chiamato sincronizzazione file.

Per i file di codice sorgente, questo comportamento è chiamato ricaricamento a caldo e supporta i seguenti tipi di file:

  • Vai: *.go
  • Java: *.java, *.kt, *.scala, *.groovy, *.clj
  • NodeJS: *.js, *.mjs, *.CPU, *.litcaffè, *.json

Con il ricaricamento a caldo configurato, Skaffold rileva le modifiche ai file supportati e le sincronizza con il container in esecuzione sul tuo cluster. Le modifiche ai tipi di file che non supportano il ricaricamento a caldo attivano la rigenerazione dell'immagine e il riavvio del pod.

La sincronizzazione automatica dei file e il ricaricamento a caldo sono abilitati per impostazione predefinita quando lavori con Buildpacks come builder preferito. Per altri builder come Docker, puoi specificare una sezione sync nel file skaffold.yaml per l'artefatto che stai personalizzando.

L'impostazione di sincronizzazione può essere una delle seguenti (in ordine di preferenza):

  • auto: Skaffold configura automaticamente la sincronizzazione. (solo per gli artefatti Jib e Buildpacks). Questa è l'impostazione predefinita per i Buildpack.
  • infer: le destinazioni per ogni file modificato vengono dedotte dallo strumento di creazione.
  • manual: devi specificare i file nell'area di lavoro locale e la loro destinazione nel container in esecuzione.

La seguente sezione sync di esempio in un file skaffold.yaml specifica una sincronizzazione manual per sincronizzare tutti i file HTML /static-html nella cartella static di un contenitore:

build:
  artifacts:
    - image: gcr.io/k8s-skaffold/node-example
      context: node
      sync:
        manual:
          - src: 'static-html/*.html'
            dest: static

Per informazioni dettagliate sulla sincronizzazione dei file e sulla specifica delle regole di sincronizzazione, consulta la guida di Skaffold sulla sincronizzazione dei file.

Aggiungere nuove funzionalità durante lo sviluppo su Kubernetes

Dopo aver configurato la sincronizzazione dei file e il ricaricamento a caldo, avvia un ciclo di iterazione e aggiungi altre funzionalità al progetto. Il deployment delle modifiche nel cluster Kubernetes viene eseguito senza interrompere e rimuovere il deployment, creare e taggare manualmente l'immagine o aggiornare il cluster.

Un ciclo di iterazione standard è simile al seguente:

  1. Apporta una modifica al progetto. Ad esempio, se utilizzi l'app guestbook Java di Cloud Code, aggiungi un nuovo endpoint alla classe FrontendController come segue:

    1. Apri il file FrontendController.java da src/main/java/cloudcode/guestbook/frontend e aggiungi quanto segue:

      @RequestMapping("/greeting")
@ResponseBody
public String greeting(@RequestParam(value="name", defaultValue="World") String name) {
   return String.format("Hello from Kubernetes with IntelliJ, %s!", name);
}

    2. Aggiungi le importazioni necessarie per le nuove annotazioni, RequestMapping e ResponseBody.

  2. Salva le modifiche (Ctrl/Cmd+S) o crea il progetto.

    Puoi visualizzare i log di avanzamento e deployment nella finestra della console. Dopo il deployment delle modifiche, conferma gli aggiornamenti.

  3. Per terminare la sessione di sviluppo continuo, fai clic sull'icona Interrompi.

    Cloud Code elimina tutte le risorse Kubernetes utilizzate per la sessione di sviluppo.

Sviluppare applicazioni di microservizi utilizzando le configurazioni Skaffold

Durante lo sviluppo di applicazioni basate su microservizi, può essere utile lavorare su sezioni separate in modo indipendente per semplificare il debug e il deployment.

Puoi sviluppare ed eseguire il debug di parti della tua applicazione in modo indipendente suddividendo l'applicazione in moduli Skaffold. Ad esempio, l'esempio di Bank of Anthos è un'applicazione contenente dieci microservizi. Il file skaffold.yaml dell'esempio raggruppa questi servizi in cinque moduli skaffold denominati setup, db, frontend, backend e loadgenerator.

Definizione dei moduli Skaffold e delle dipendenze di configurazione

Per definire i moduli Skaffold e le dipendenze della configurazione:

  1. Apri il progetto in cui vuoi definire i moduli.

  2. Apri il file skaffold.yaml.

  3. Se il file skaffold.yaml ha più configurazioni, specifica la riga seguente per rendere una configurazione un modulo Skaffold:

    metadata:
  name: MODULE_NAME_1

    Ad esempio, nella Bank of Anthos skaffold.yaml, il modulo db definisce i deployment dei database:

    apiVersion: skaffold/v3
kind: Config
metadata:
  name: db # module defining database deployments
requires:
- configs:
  - setup
build:
  artifacts:
  - image: accounts-db
    context: src/accounts-db
  - image: ledger-db
    context: src/ledger-db
manifests:
  rawYaml:
  - dev-kubernetes-manifests/accounts-db.yaml
  - dev-kubernetes-manifests/ledger-db.yaml
deploy:
  kubectl: {}

  4. Per le configurazioni che si basano su un'altra configurazione di cui viene eseguito il deployment prima del deployment della configurazione attuale, devi aggiungere la configurazione alle dipendenze. Per specificare una dipendenza di configurazione, aggiungi un elenco configs alla sezione requires del file skaffold.yaml.

    Ad esempio, il file skaffold.yaml di Bank of Anthos include la dipendenza di configurazione setup.

    Per definire una dipendenza, aggiungi quanto segue al file skaffold.yaml dove DEPENDENCY_NAME è il nome della dipendenza.

    requires:
    - configs: DEPENDENCY_NAME

    Le configurazioni elencate in questo modo possono fare riferimento alle dipendenze definite nello stesso file o in altri file skaffold.yaml nel progetto attuale.

  5. Testa le dipendenze di configurazione creando ciascuno dei moduli Skaffold separatamente per assicurarti che il deployment venga eseguito con le rispettive dipendenze seguendo i passaggi descritti in Creare moduli Skaffold specifici e le relative dipendenze.

Creare moduli Skaffold specifici e le rispettive dipendenze

Dopo aver definito i moduli e le rispettive dipendenze, puoi specificare quali moduli eseguire con il codice cloud nel file launch.json.

Se per il tuo progetto non è definito un file launch.json, quando esegui Cloud Code: Run on Kubernetes o Cloud Code: Debug on Kubernetes, ti viene richiesto di selezionare i moduli da creare:

  1. Apri la tavolozza dei comandi (Ctrl/Cmd+Shift+P) ed esegui Cloud Code: Run on Kubernetes.
  2. Fai clic su Seleziona moduli.
  3. Scegli i moduli di cui vuoi eseguire il deployment e fai clic su OK. Ogni modulo viene creato con le sue dipendenze.
  4. Quando richiesto, scegli un registro di immagini, quindi premi Enter.

Se il progetto ha un launch.json, segui questi passaggi per scegliere i moduli Skaffold da creare:

  1. Apri il file launch.json del progetto.

  2. Modifica la configurazione di avvio per aggiungere l'opzione skaffoldFlags con un elenco delimitato da virgole di modules da creare. Se skaffoldFlags viene omesso, vengono creati tutti i moduli.

      {
    "name": "Run on Kubernetes",
    "type": "cloudcode.kubernetes",
    "request": "launch",
    "skaffoldConfig": "${workspaceFolder}/skaffold.yaml",
    "skaffoldFlags": {
       "modules": ["MODULE_NAME_2,MODULE_NAME_2"],
    "watch": true,
    "cleanUp": true,
    }
  }

  3. Esegui la configurazione di avvio che hai modificato.

Sviluppo continuo su Kubernetes

Dopo aver configurato la destinazione di esecuzione con le opzioni desiderate, puoi scegliere un'esecuzione regolare dell'applicazione o avviare un ciclo di iterazione di sviluppo nel tuo IDE per propagare le modifiche apportate all'origine e alle dipendenze all'applicazione attiva.

La destinazione di esecuzione Esegui su Kubernetes avvia il ciclo di sviluppo sul tuo cluster Kubernetes. Dopo aver avviato il ciclo di sviluppo, Cloud Code, utilizzando Skaffold, crea un'immagine per il progetto, la codifica, ne esegue il push nel repository configurato e utilizza kubectl per eseguire il deployment dei manifest Kubernetes del progetto.

  1. Personalizza il tuo deployment utilizzando le opzioni di configurazione disponibili.
  2. Se la tua applicazione è configurata per utilizzare i moduli Skaffold, puoi selezionare moduli specifici di cui creare o eseguire il deployment.
  3. Apri la tavolozza dei comandi (premi Ctrl/Cmd+Shift+P), quindi esegui il comando Cloud Code: Run on Kubernetes.
  4. Conferma se utilizzare l'attuale contesto Kubernetes per eseguire l'app (o passa a uno dei due preferiti). Per ulteriori informazioni sulla configurazione di un contesto Kubernetes, consulta Impostazione della configurazione.

  5. Se hai scelto un cluster remoto come contesto, quando richiesto, scegli un registro di immagini a cui eseguire il push delle immagini. Se utilizzi Container Registry, puoi navigare fino a un registro esistente o specificare il nome di un registro da creare. Se nel tuo progetto è abilitata l'API Artifact Registry e almeno un repository Artifact Registry, puoi cercare e selezionare un repository Artifact Registry esistente.

    Cloud Code crea i container, ne esegue il push al registro, applica le configurazioni Kubernetes al cluster e attende l'implementazione.

Passaggi successivi