DevSpace è uno strumento open source che aiuta gli sviluppatori a distribuire rapidamente applicazioni cloud-native ai cluster Kubernetes. Astrae gran parte della tradizionale complessità di Kubernetes in modo da poter tornare a scrivere codice.
DevSpace è indipendente dalla piattaforma e funziona con cluster che vanno dalla tua macchina locale ai servizi pubblici gestiti più diffusi. Lo strumento è una CLI che automatizza le operazioni utilizzando le API Kubernetes. Non è necessario installare nulla all’interno del cluster per utilizzare DevSpace.
Pratiche di sviluppo moderne per Kubernetes
DevSpace porta molti aspetti della moderna esperienza di programmazione delle app nelle distribuzioni basate su Kubernetes. Ti consente di eseguire il tuo ambiente di sviluppo sul tuo cluster con il supporto per il ricaricamento automatico a caldo. Quando un file locale cambia, DevSpace aggiorna automaticamente i tuoi contenitori con il nuovo contenuto.
Il port forwarding integrato significa che puoi usare localhost per accedere alla tua distribuzione. Non è necessario aprire porte o configurare HTTP Ingress sui cluster di sviluppo, offrendo un’esperienza di sviluppo migliorata e una maggiore sicurezza.
DevSpace aiuta anche il debug. Supporta l’impostazione di punti di interruzione utilizzando uno strumento Remote Debugger, offrendo l’ispezione in tempo reale delle applicazioni containerizzate nel cloud. È anche facile visualizzare i log di un contenitore o avviare una sessione di terminale senza eseguire comandi Kubectl ingombranti.
Un’interfaccia web in esecuzione su localhost ti consente di monitorare e interagire con l’applicazione in esecuzione. Puoi uscire del tutto dal tuo terminale se preferisci un’esperienza più visiva.
Installazione di DevSpace
DevSpace è distribuito come binario autonomo che funziona su sistemi Windows, Mac e Linux. Sono disponibili diverse opzioni di installazione. Ecco il comando consigliato per scaricare DevSpace per Linux e aggiungere la CLI al tuo percorso:
dev sudo install devspace /usr/local/bin
In alternativa puoi usare npm, il gestore di pacchetti Node, per installare e aggiornare DevSpace:
npm install -g devspace
Questo comando ti darà un funzionamento devspace nel tuo percorso, a condizione che tu abbia già installato npm.
DevSpace utilizza il tuo “attivo”KUBE_CONTEXT” allo stesso modo di altri strumenti dell’ecosistema come Kubectl e Helm. Set KUBECONFIG a un file di configurazione compatibile con Kubectl che definisce la connessione del cluster:
export KUBECONFIG=/path/to/kubeconfig.yaml # Uses $KUBECONFIG devspace deploy
Creare un progetto
Il primo passo nella creazione con DevSpace è inizializzare la directory del progetto. Questo creerà un devspace.yaml file che contiene la configurazione di DevSpace per il tuo repository.
devspace init
Ti verrà chiesto di selezionare la routine di distribuzione che prevedi di utilizzare. DevSpace può funzionare con Kubectl, Helm o Kustomize quando avvii la tua app nel tuo cluster.
Il suggerito QUICKSTART opzione è un grafico speciale che ti consente di definire i componenti della tua applicazione, come il server Web frontend, il server API backend e il database, invece di fornire grafici Helm o manifest Kubectl creati manualmente. Usalo se stai costruendo un sistema con una struttura convenzionale e non vuoi perdere tempo a creare le tue risorse Kubernetes.
Segui le istruzioni per fornire a DevSpace il percorso del tuo Dockerfile. Dovrai fornire l’autenticazione del registro e alcune informazioni di base sulla tua immagine, come la porta su cui è in ascolto. DevSpace produrrà automaticamente una configurazione pronta per l’uso che ti consentirà di eseguire devspace deploy per pubblicare la tua app su Kubernetes.
Se non utilizzi l’opzione di avvio rapido, dovrai fornire il percorso ai grafici Helm o ai manifest Kubernetes. Segui le istruzioni per creare una configurazione iniziale. Una volta usciti dalla procedura guidata di configurazione, puoi continuare ad aggiungere immagini e distribuzioni extra modificando manualmente il tuo devspace.yaml file.
Aggiungere un’immagine
I progetti DevSpace vengono creati da una o più immagini contenitore. Per registrare un’immagine nel tuo progetto, aggiungila sotto il images chiave nel tuo devspace.yamlfile:
images: app: image: example.com/example/image:latest dockerfile: ./Dockerfile build: disabled: true
Il image Il campo definisce il nome del tag dell’immagine. Il dockerfile il campo è facoltativo; quando impostato, dovrebbe fare riferimento al percorso del Dockerfile dell’immagine nel progetto. Le immagini con Dockerfiles verranno create automaticamente dal devspace build e devspace deploy comandi, a meno che build.disabled è true nella configurazione dell’immagine.
Le immagini sono costruite in parallelo per accelerare le prestazioni. Il --build-sequential flag obbliga le immagini a essere costruite singolarmente nell’ordine in cui sono invece specificate. DevSpace invierà automaticamente ogni immagine al rispettivo registro al termine di una build.
Le immagini non vengono ricostruite automaticamente a meno che DevSpace non rilevi una modifica nel loro Dockerfile o nei file nel loro contesto di compilazione. Puoi forzare una ricostruzione di tutte le immagini configurate con il --force-build bandiera.
Aggiunta di una distribuzione
Il secondo pezzo di a devspace.yaml è tuo deployments. Questi definiscono le risorse che verranno create all’interno del tuo cluster.
deployments: - name: "helm chart" helm: chart: name: example/example-app values: VARIABLE_OVERRIDE: "new-value" - name: "kubectl manifests" kubectl: manifests: - .kube/manifests
Questo file definisce due distribuzioni separate, una che utilizza Helm e l’altra Kubectl. Quando corri devspace deploy, sia il grafico Helm che i manifesti Kubectl verranno installati nel cluster.
Ripetendo il deploy comando aggiornerà le tue distribuzioni. DevSpace ridistribuisce solo i componenti che sono stati modificati a meno che --force-deploy viene utilizzata la bandiera.
Poiché DevSpace funziona su più cluster, promuovere la tua distribuzione dallo sviluppo alla produzione è un caso di cambiare il tuo KUBECONFIG variabile d’ambiente e riesecuzione devspace deploy. Questo ti offre un unico meccanismo coerente per la gestione di più distribuzioni indipendenti del tuo sistema.
Utilizzo dei profili
DevSpace supporta i profili che ti consentono di modificare devspace.yaml sezioni per ciascuno dei tuoi ambienti. Ogni profilo denominato può sostituire, unire e modificare i campi all’interno del file di configurazione.
Anche i profili stessi sono definiti nel tuo devspace.yaml:
images: api-server: image: example.com/api-server:latest web-server: image: example.com/web-server:latest debug: image: example.com/debug-tool:latest # ... omitted profiles: - name: production patches: - op: remove path: images.debug
I profili si attivano passando il -p o --profile flag ai comandi DevSpace. Ecco come avviare una distribuzione utilizzando il production profilo sopra definito. La distribuzione non includerà il debug immagine in quanto rimossa da una delle patch del profilo.
devspace deploy --profile production
Utilizzo di Ricarica a caldo
La funzionalità di ricarica a caldo è abilitata impostando la sincronizzazione dei file:
dev: sync: - imageSelector: example.com/api-server:latest localSubPath: ./api/ containerPath: /var/www/html excludePaths: - vendor/
Aggiungi il dev chiave come campo di primo livello nel tuo devspace.yaml, quindi usa sync per configurare la ricarica a caldo in base all’immagine. Il imageSelector corrisponde ai tag immagine a cui applicare la regola di ricarica a caldo. File da localSubPath nella tua directory di lavoro verrà sincronizzato con containerPath nelle istanze di container distribuite.
Avvia una sessione di ricarica a caldo eseguendo devspace dev o devspace sync. Il primo comando avvia tutte le funzionalità dell’ambiente di sviluppo di DevSpace, incluso il port forwarding e lo streaming di log in tempo reale.
Per impostazione predefinita, la ricarica a caldo sostituisce i file nei contenitori esistenti. È simile all’utilizzo dei volumi Docker e dei montaggi di associazione quando si lavora con istanze di container locali. In alcuni scenari, potresti voler avviare una nuova distribuzione di DevSpace quando il tuo filesystem cambia. Ciò si ottiene tramite il separato autoReload opzione:
images: api: image: example.com/api-server:latest deployments: - name: api-deployment # ... omitted dev: autoReload: paths: - ./kernel/* images: - example.com/api-server:latest deployments: - api-deployment
Questo esempio verrà ridistribuito api-deployment ogni volta che i file nel tuo locale kernel cambio di directory. Questo è l’ideale quando modifichi file che devono essere eseguiti attraverso un processo di compilazione per renderli utili ai tuoi contenitori.
Port forwarding
Il port forwarding è configurato tramite il dev.ports campo nel tuo devspace.yaml. È supportato anche l’inoltro inverso, consentendo localhost gli indirizzi nei contenitori vengono mappati alle porte sul computer locale.
dev: ports: - imageSelector: example.com/api-server:latest forward: - port: 8080 remotePort: 80 reverseForward: - port: 9000 remote: 9000
Questo esempio imposta un inoltro da localhost:8080 sulla tua macchina alla porta 80 in contenitori che eseguono il example.com/api-server Immagine. C’è anche una retromarcia in avanti che indirizza il traffico all’interno del container verso localhost:9000 torna alla porta 9000 sulla tua macchina.
Altre caratteristiche
Oltre alle funzionalità trattate qui, DevSpace offre anche supporto per diversi altri gruppi di funzionalità che consentono di monitorare le distribuzioni, interagire con i contenitori e configurare flussi di lavoro di sviluppo avanzati:
-
Lancio automatico del terminale consente di avviare una sessione di shell remota ogni volta che si esegue
devspace dev. - Apertura URL automatica avvia siti Web e app Web nel browser quando si accede alla modalità di sviluppo.
- Registrazione configurabile definisce quali contenitori dovrebbero apparire nel flusso di log della modalità dev.
- Comandi personalizzati agire come scorciatoie per azioni comuni, aiutando i nuovi membri del team a interagire con le tue distribuzioni senza dover apprendere lunghi processi in Kubectl.
- Ganci eseguire comandi durante il processo di distribuzione, consentendo di configurare manualmente i contenitori o registrare nuove distribuzioni in un servizio di monitoraggio centralizzato.
-
L’interfaccia utente viene eseguito automaticamente in modalità di sviluppo con
devspace deve può essere aperto nel browser utilizzandodevspace ui.
DevSpace offre anche plugin che possono aggiungere ancora più funzionalità al sistema. L’API del plug-in supporta l’installazione da URL remoti o script locali e facilita nuovi comandi, hook e variabili. Lo sviluppo del proprio plug-in fornisce un modo per standardizzare l’utilizzo di DevSpace su più progetti indipendenti.
Distribuzioni in pipeline CI/CD
DevSpace può gestire le distribuzioni di produzione come parte della pipeline CI/CD. Fornisce un’immagine Docker ufficiale e supporta l’uso non interattivo se includi selettori espliciti come -l per l’etichetta nei tuoi comandi.
Una distribuzione all’interno di una pipeline CI potrebbe essere simile a questa:
echo $KUBECONFIG_CI_VARIABLE > /path/to/kubeconfig export KUBECONFIG=/path/to/kubeconfig devspace deploy --profile production --timeout 60 --wait --skip-build
Questo distribuirà la tua applicazione usando il production Profilo DevSpace. Il --skip-build flag indica a DevSpace di non creare le tue immagini. Le build in genere dovrebbero essere gestite come una fase separata all’inizio della pipeline.
Il --wait flag costringe DevSpace ad attendere la disponibilità del conteggio Pod specificato nel tuo devspace.yaml, invece di terminare immediatamente dopo aver eseguito il comando. Questo è più appropriato per un ambiente CI in cui si desidera confermare che il carico di lavoro è attivo. Consentire a DevSpace di uscire senza attendere potrebbe significare che la pipeline viene contrassegnata come riuscita anche se si verifica un problema di distribuzione.
Conclusione
DevSpace sta guadagnando terreno come strumento di distribuzione Kubernetes orientato agli sviluppatori che fornisce utili astrazioni per le operazioni chiave. Riduce la quantità di YAML necessaria per avviare i contenitori in un cluster, sostituendolo con semplici chiavi di configurazione e comandi del terminale che definiscono, costruiscono e avviano le immagini.
Essendo uno strumento indipendente dalla piattaforma e dall’ambiente, DevSpace consente agli sviluppatori di preoccuparsi meno delle caratteristiche uniche dei singoli cluster. Indipendentemente dall’obiettivo di distribuzione, l’esperienza complessiva è simile alla creazione di un sistema tradizionale sul computer locale. Ciò aiuta ad ammorbidire la curva di apprendimento di Kubernetes mappando i concetti a pratiche di sviluppo più universalmente comprese.
