Espacio de desarrollo es una herramienta de código abierto que ayuda a los desarrolladores a implementar rápidamente aplicaciones nativas de la nube en clústeres de Kubernetes. Elimina gran parte de la complejidad tradicional de Kubernetes para que puedas volver a escribir código.
DevSpace es independiente de la plataforma y funciona con clústeres que van desde su máquina local hasta servicios públicos administrados populares. La herramienta es una CLI que automatiza las operaciones utilizando las API de Kubernetes. No necesita instalar nada dentro de su clúster para usar DevSpace.
Prácticas de desarrollo modernas para Kubernetes
DevSpace aporta muchos aspectos de la experiencia de programación de aplicaciones modernas a las implementaciones basadas en Kubernetes. Le permite ejecutar su entorno de desarrollo en su clúster con soporte para recarga automática en caliente. Cuando cambia un archivo local, DevSpace actualiza automáticamente sus contenedores con el nuevo contenido.
El reenvío de puertos integrado significa que puede utilizar localhost para acceder a su implementación. No necesita abrir puertos ni configurar entradas HTTP en clústeres de desarrollo, lo que ofrece una experiencia de desarrollador mejorada y mayor seguridad.
DevSpace también ayuda a la depuración. Admite la configuración de puntos de interrupción mediante una herramienta de depuración remota, que ofrece inspección en vivo de aplicaciones en contenedores en la nube. También es fácil ver los registros de un contenedor o iniciar una sesión de terminal sin ejecutar comandos difíciles de manejar de Kubectl.
Una interfaz web que se ejecuta en localhost le permite monitorear e interactuar con su aplicación en ejecución. Puedes escapar de tu terminal por completo si prefieres una experiencia más visual.
Instalación de DevSpace
DevSpace se distribuye como un binario autónomo que funciona en sistemas Windows, Mac y Linux. Varios opciones de instalación están disponibles. Este es el comando recomendado para descargar DevSpace para Linux y agregar la CLI a su ruta:
devsudo install devspace /usr/local/bin
Alternativamente, puedes usar npm, el administrador de paquetes de Node, para instalar y actualizar DevSpace:
npm install -g devspace
Este comando le brindará un espacio de desarrollo funcional en su ruta, siempre que ya tenga npm instalado.
DevSpace utiliza su “KUBE_CONTEXT” activo de la misma manera que otras herramientas del ecosistema como Kubectl y Helm. Configure KUBECONFIG en un archivo de configuración compatible con Kubectl que defina su conexión de clúster:
export KUBECONFIG=/path/to/kubeconfig.yaml# Uses $KUBECONFIG
devspace deploy
Creando un proyecto
El primer paso para construir con DevSpace es inicializar el directorio de su proyecto. Esto creará un archivo devspace.yaml que contiene la configuración de DevSpace para su repositorio.
devspace init
Se le pedirá que seleccione la rutina de implementación que planea usar. DevSpace puede funcionar con Kubectl, Helm o Kustomize al iniciar su aplicación en su clúster.
La opción QUICKSTART sugerida es una tabla especial que le permite definir componentes de su aplicación, como su servidor web frontend, servidor API backend y base de datos, en lugar de proporcionar gráficos Helm creados manualmente o manifiestos Kubectl. Úselo si está creando un sistema con una estructura convencional y no quiere perder tiempo creando sus propios recursos de Kubernetes.
Siga las indicaciones para proporcionar a DevSpace la ruta a su Dockerfile. Deberá proporcionar autenticación de registro y cierta información básica sobre su imagen, como el puerto en el que escucha. DevSpace producirá automáticamente una configuración lista para usar que le permitirá ejecutar la implementación de devspace para que su aplicación esté activa en Kubernetes.
Si no utiliza la opción de inicio rápido, deberá proporcionar la ruta a sus gráficos de Helm o manifiestos de Kubernetes. Siga las indicaciones para crear una configuración inicial. Una vez que salga del asistente de configuración, puede continuar agregando imágenes e implementaciones adicionales editando manualmente su archivo devspace.yaml.
Agregar una imagen
Los proyectos de DevSpace se crean a partir de una o más imágenes de contenedor. Para registrar una imagen en su proyecto, agréguela bajo la clave de imágenes en su archivo devspace.yaml:
images:app:
image: example.com/example/image:latest
dockerfile: ./Dockerfile
build:
disabled: true
El campo de imagen define el nombre de la etiqueta de imagen. El campo dockerfile es opcional; cuando está configurado, debe hacer referencia a la ruta al Dockerfile de la imagen en su proyecto. Las imágenes con Dockerfiles se crearán automáticamente mediante los comandos devspace build y devspace implementar, a menos que build.disabled sea verdadero en la configuración de la imagen.
Las imágenes son construido en paralelo para acelerar el rendimiento. La bandera –build-sequential obliga a que las imágenes se construyan individualmente en el orden en que se especifican. DevSpace enviará automáticamente cada imagen a su registro respectivo una vez que se complete la compilación.
Las imágenes no se reconstruyen automáticamente a menos que DevSpace detecte un cambio en su Dockerfile o en los archivos en su contexto de compilación. Puede forzar una reconstrucción de todas las imágenes configuradas con el indicador –force-build.
Agregar una implementación
La segunda parte de devspace.yaml son sus implementaciones. Estos definen los recursos que se crearán dentro de su clúster.
deployments:- name: "helm chart"
helm:
chart:
name: example/example-app
values:
VARIABLE_OVERRIDE: "new-value"
- name: "kubectl manifests"
kubectl:
manifests:
- .kube/manifests
Este archivo define dos implementaciones independientes, una que utiliza Helm y la otra Kubectl. Cuando ejecute la implementación de devspace, tanto el gráfico de Helm como los manifiestos de Kubectl se instalarán en su clúster.
Repetir el comando de implementación actualizará sus implementaciones. DevSpace solo vuelve a implementar los componentes que cambiaron a menos que se use el indicador –force-deploy.
Como DevSpace funciona en clústeres, promover su implementación desde el desarrollo a la producción es un caso de cambiar su variable de entorno KUBECONFIG y volver a ejecutar la implementación de devspace. Esto le brinda un mecanismo único y consistente para administrar múltiples implementaciones independientes de su sistema.
Usando perfiles
DevSpace admite perfiles que le permiten modificar las secciones devspace.yaml para cada uno de sus entornos. Cada perfil nombrado puede reemplazar, fusionar y modificar campos dentro de su archivo de configuración.
Los perfiles en sí también se definen en su 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
Los perfiles se activan pasando el indicador -p o –profile a los comandos de DevSpace. A continuación se explica cómo iniciar una implementación utilizando el perfil de producción definido anteriormente. La implementación no incluirá la imagen de depuración, ya que uno de los parches del perfil la elimina.
devspace deploy --profile production
Usando recarga en caliente
La funcionalidad de recarga en caliente se habilita configurando la sincronización de archivos:
dev:sync:
- imageSelector: example.com/api-server:latest
localSubPath: ./api/
containerPath: /var/www/html
excludePaths:
- vendor/
Agregue la clave de desarrollo como un campo de nivel superior en su devspace.yaml, luego use la sincronización para configurar la recarga en caliente por imagen. imageSelector coincide con etiquetas de imágenes a las que aplicar la regla de recarga en caliente. Los archivos de localSubPath en su directorio de trabajo se sincronizarán con containerPath en instancias de contenedor implementadas.
Inicie una sesión de recarga en caliente ejecutando devspace dev o devspace sync. El ex comando inicia todas las funciones del entorno de desarrollador de DevSpace, incluido el reenvío de puertos y la transmisión de registros en vivo.
La recarga en caliente tiene como valor predeterminado reemplazar archivos en contenedores existentes. Es similar al uso de volúmenes Docker y montajes vinculados cuando se trabaja con instancias de contenedores locales. En algunos escenarios, es posible que desee iniciar una nueva implementación de DevSpace cuando cambie su sistema de archivos. Esto se logra a través de la opción autoReload separada:
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
Este ejemplo volverá a implementar la implementación de API cada vez que cambien los archivos en el directorio de su kernel local. Esto es ideal cuando modifica archivos que deben ejecutarse a través de un proceso de compilación para que sean útiles para sus contenedores.
Reenvío de puertos
El reenvío de puertos se configura a través del campo dev.ports en su devspace.yaml. También se admite el reenvío inverso, lo que permite que las direcciones de host local en sus contenedores se asignen a los puertos de su máquina local.
dev:ports:
- imageSelector: example.com/api-server:latest
forward:
- port: 8080
remotePort: 80
reverseForward:
- port: 9000
remote: 9000
Este ejemplo configura un reenvío desde localhost:8080 en su máquina al puerto 80 en contenedores que ejecutan la imagen example.com/api-server. También hay un avance inverso que dirige el tráfico dentro del contenedor a localhost:9000 de regreso al puerto 9000 de su máquina.
Otras características
Además de las capacidades que se tratan aquí, DevSpace también ofrece soporte para varios otros grupos de funciones que le permiten monitorear implementaciones, interactuar con contenedores y configurar flujos de trabajo de desarrollo avanzados:
- Lanzamientos automáticos de terminales le permite iniciar una sesión de shell remota cada vez que ejecuta devspace dev.
- Apertura automática de URL inicia sitios web y aplicaciones web en su navegador cuando ingresa al modo de desarrollo.
- Registro configurable define qué contenedores deben aparecer en el flujo de registro del modo de desarrollo.
- Comandos personalizados Actúan como atajos para acciones comunes, ayudando a los nuevos miembros del equipo a interactuar con sus implementaciones sin necesidad de aprender procesos largos en Kubectl.
- Manos ejecute comandos durante el proceso de implementación, lo que le permitirá configurar contenedores manualmente o registrar nuevas implementaciones en un servicio de monitoreo centralizado.
- La interfaz de usuario se ejecuta automáticamente en modo de desarrollo con devspace dev y se puede abrir en su navegador usando devspace ui.
DevSpace también ofrece complementos que puede agregar aún más funcionalidad al sistema. La API del complemento admite la instalación desde URL remotas o scripts locales y facilita nuevos comandos, enlaces y variables. Desarrollando el tuyo El complemento proporciona una manera de estandarizar el uso de DevSpace en múltiples proyectos independientes.
Implementaciones en canalizaciones de CI/CD
DevSpace puede manejar implementaciones de producción como parte de su proceso de CI/CD. Proporciona un imagen oficial de Docker y admite el uso no interactivo si incluye selectores explícitos como -l para etiqueta en sus comandos.
Una implementación dentro de una canalización de CI podría verse así:
echo $KUBECONFIG_CI_VARIABLE > /path/to/kubeconfigexport KUBECONFIG=/path/to/kubeconfig
devspace deploy --profile production --timeout 60 --wait --skip-build
Esto implementará su aplicación utilizando el perfil de producción de DevSpace. El indicador –skip-build le indica a DevSpace que no cree sus imágenes. Por lo general, las compilaciones deben manejarse como una etapa separada en una etapa anterior del proceso.
El indicador –wait obliga a DevSpace a esperar la disponibilidad del recuento de pods especificado en su devspace.yaml, en lugar de finalizar inmediatamente después de ejecutar el comando. Esto es más apropiado para un entorno de CI en el que desea confirmar que su carga de trabajo está activa. Permitir que DevSpace salga sin esperar podría significar que su proceso se marque como exitoso incluso si hay un problema de implementación.
Conclusión
DevSpace está ganando terreno como herramienta de implementación de Kubernetes orientada a desarrolladores que proporciona abstracciones útiles para operaciones clave. Reduce la cantidad de YAML necesaria para lanzar contenedores en un clúster, reemplazándolo con claves de configuración simples y comandos de terminal que definen, crean e inician imágenes.
Como herramienta independiente de la plataforma y el entorno, DevSpace permite a los desarrolladores preocuparse menos por las características únicas de los clústeres individuales. Independientemente del objetivo de implementación, la experiencia general es similar a la creación de un sistema tradicional en su máquina local. Esto ayuda a suavizar la curva de aprendizaje de Kubernetes al mapear los conceptos a prácticas de desarrollo más universalmente entendidas.
