Introducción
El cilio está utilizando la inyección de dependencia (a través dePKG/colmena) para conectar la inclinación, el inicio y la detención de sus componentes.
Inyección de dependencia(Di) es atécnico para separar el uso de objetos de su creación e initialización.Esencialmente, la inyección de dependencia se trata de automatizar el manejo de las dependencias temanuales.Los constructores de objetos solo necesitan declarar dependencias como parámetros de función y la biblioteca maneja el resto.Esto lo hace con la construcción de una arquitectura modular libremente acoplada a medida que se elimina para la centralización de la inicialización y la configuración.También reduce la inclinación a usar variables globales sobre el paso explícito de objetos, que a menudo es una fuente de errores (debido a un orden de inicialización inesperado) y difícil de manejar en las pruebas (ya que el estado debe restaurarse para la siguiente prueba).Con los componentes de inyección de dependencia se describen como valores simples (CelúlaEn nuestro sabor de DI) que permite la visualización de dependencias de componentes internos y abriendo la arquitectura interna para la inspección.
La inyección de dependencia y la maquinaria descrita aquí son solo una herramienta para protegernos hacia el objetivo real: una arquitectura de software modular que puede ser fácilmente entendida, extendida, reutilizada, probada y refactorizada por un gran grupo de desarrolladores con una superposición mínima entre módulos.Para lograr este wealso, debe tener en cuenta la modularidad al diseñar la arquitectura y las API.
Colmena y células
Las aplicaciones de cilio se componen utilizando la inyección de dependencia de tiempo de ejecución de un conjunto de componentes modulares establecidos llamados células que componen juntas para formar una colmena (como la colmena de Inbee).Luego se puede suministrar una colmena con configuración y ejecutar.Para que sean de lo que se trata, así es como una simple aplicación de servidor HTTP modular aprovecharía la colmena:
paquete servidor// La celda del servidor implementa un servidor HTTP genérico.Proporciona la API de 'servidor'// para registrar manejadores de solicitud.//// módulo () crea una colección con nombre de celdas.era Celúla = celúla.Módulo( "http-server", // Identificador de módulo (para, por ejemplo, registro y rastreo) "Servidor HTTP", // Título del módulo (para documentación) // Proporcionar la aplicación el constructor para el servidor. celúla.Proporcionar(Nuevo), // config registra una configuración cuando se proporciona con los valores predeterminados // y una implementación de flags () para registrar los indicadores de configuración. celúla.Configuración(defaultServerConfig),)// El servidor permite registrar controladores de solicitudes con el servidor HTTPtipo Servidor interfaz { Escucha() cadena Registrandler(camino cadena, fn http.Handlerfunc)}función Nuevo(LC celúla.Ciclo vital, CFG Configuración del servidor) Servidor { // Inicializar http.server, registrar los ganchos de inicio y detener el ciclo de vida // para comenzar y detener el servidor y devolver una implementación de // 'servidor' para otras celdas para registrar manejadores. // ...}tipo Configuración del servidor estructura { Puerto del servidor uint16}era defaultServerConfig = Configuración del servidor{ Puerto del servidor: 8080,}función (definición Configuración del servidor) Banderas(banderas *Pflag.Bandera) { // Registre el indicador de "puerto de servidor".Hive por convención asigna el indicador al Servidor // campo. banderas.Uint16("Servidor-Port", definición.Puerto del servidor, "Establece el puerto de escucha del servidor HTTP")}
Con el servidor HTTP genérico anterior en elservidorpaquete, ahora podemos implementar un controlador simple /hola en elHolapaquete:
paquete Hola// La celda Hello implementa y registra un controlador de saludo al servidor HTTP.//// Esta celda no es un módulo, sino solo una invocatoria simple.Un invocador// es una celda que, a diferencia de proporcionar, siempre se ejecuta.Invocar funciones// puede depender de los valores que los constructores registrados con proporcionar () pueden// devolver.Luego se llaman a estos constructores y sus resultados recordados.era Celúla = celúla.Invocar(RegisterHelloHandler)función HelloHandler(w http.Responsewriter, req *http.Pedido) { w.Escribir([]byte("Hola"))}función RegisterHelloHandler(SRV servidor.Servidor) { SRV.Registrandler("/Hola", HelloHandler)}
Y luego junte los dos en una aplicación simple:
paquete principalera ( // Ejemplohive es una aplicación con un servidor HTTP y un controlador // a /hola. sujeción = colmena.Nuevo( servidor.Celúla, Hola.Celúla, ) // cmd es el comando root para esta aplicación.Carreras // Ejemplohive cuando se ejecuta. CMD *cobra.Dominio = Ycobra.Dominio{ Usar: "ejemplo", Correr: función(CMD *cobra.Dominio, argumentos []cadena) { // run () ejecutará todas las funciones de invocación, seguido de Start Hooks // y luego esperará la señal de interrupción antes de ejecutar ganchos de detención // y regreso. sujeción.Correr() }, })función principal() { // registrar todos los indicadores de línea de comandos desde cada celda de configuración al // Flag-set de nuestro comando. sujeción.Flags de registro(CMD.Banderas()) // Agregue el submand "Hive" para inspeccionar la aplicación. CMD.Admand(sujeción.Dominio())) // Ejecutar el comando root. CMD.Ejecutar()}
Si prefiere aprender con el ejemplo, puede encontrar un examen más completo y ejecutable a partir dePKG/Hive/Ejemplo.Intenta ejecutarlo conir correr .Y también intentair correr . colmena.Y si está interesado en cómo se implementa todo esto internamente, verPKG/HIVE/Ejemplo/Mini, Un ejemplo mínimo de cómo hacer inyección de dependencia con reflexión.
La API de la colmena
Con el ejemplo, el ejemplo, con suerte, que ahora ha despertado el apetito, echaremos un vistazo adecuado a la API de la colmena.
PKG/colmenaproporciona el tipo de colmena ycolmena.Nuevoconstructor.locolmena.El tipo se puede considerar como un contenedor de aplicación, compuesto a partir de células:
era myhive = colmena.Nuevo(foo.Celúla, bar.Celúla)// Llame Run () para ejecutar la colmena.myhive.Correr() // inicio (), espere la señal (CTRL-C) y luego pare ()// Hive también se puede iniciar y detenerse directamente.Útil en las pruebas.si errar : = myhive.Comenzar(CTX); errar ! = nulo { / * ... */ }si errar : = myhive.Detener(CTX); errar ! = nulo { / * ... */ }// La configuración de Hive se puede registrar con un comando COBRA:colmena.Flags de registro(CMD.Banderas())// Hive también proporciona un submand para inspeccionarlo:CMD.Admand(colmena.Dominio())
PKG/colmena/celularDefine la interfaz celular quecolmena.new ()consume y las siguientes funciones para crear células:
Módulo: Un conjunto con nombre de células.
Proporcionar: Proporciona constructor (s) a la colmena.Perezoso y solo invocado si hace referencia por una función de invocación (directa o indirectamente a través de otro constructor).
Proporcionarprivate: Proporciona constructores privados a un módulo y sus submódulos.
Decorar: Envuelve un conjunto de celdas con una función decoradora para proporcionar a estas celdas objetos aumentados.
Configuración: Proporciona una estructura de configuración a la colmena.
Invocar: Registra una función de invocación para instanciar e inicializar objetos.
Métrico: Proporciona métricas a la colmena.
Hive también de forma predeterminada proporciona los siguientes objetos disponibles a nivel mundial:
Ciclo vital: Métodos para registrar funciones de inicio y parada que se ejecutan cuando la colmena se inicia y se detiene. Los ganchos se agregan en orden de dependencia (ya que los constructores se invocan en orden de dependencia).
Apagado: Permite cerrar la colmena con gracia desde cualquier lugar en caso de un error fatal después del inicio.
logrus.fieldlogger: Interfaz al registrador.Módulo () lo decora consubsys =.ID>
Proporcionar
Ahora echaremos un vistazo a cada uno de los diferentes tipos de células, comenzando con proporcionar (), que registra uno o más constructores con la colmena:
// FUNC Proporcionar (CTORS cualquier ...) Celdatipo A interfaz {}función dado() A { devolver A{} }tipo B interfaz {}función Newb(A) B { devolver B{} }// SimpleCell proporciona A y Bera SimpleCell celúla.Celúla = celúla.Proporcionar(dado, Newb)
Si los constructores toman muchos parámetros, queremos agruparlos en una estructura concelular.En, y por el contrario, si hay muchos valores de retorno, en una estructura concelda..Este recolector para desempacarlos:
tipo parámetros estructura { celúla.En A A B B Ciclo vital celúla.Ciclo vital}tipo afuera estructura { celúla.Afuera do do D D mi mi}función Newcde(parámetros parámetros) afuera { ... }era Celúla = celúla.Proporcionar(Newcde)
A veces queremos depender de un grupo de valores que compartan el mismo tipo, p.para recolectar manejadores o métricas API.Esto se puede hacer congrupos de valorAl combinarcelular.Enycelda.con elgrupoEtiqueta de estructura:
tipo Control estructura { celúla.Afuera Entrenador de animales Entrenador de animales `Grupo:" manejadores "`}función Namhellohandler() Control { ... }función Nuevo eventhandler(SRC eventos.Fuente) Control { ... }tipo Baramas de servidor estructura { celúla.En Manejadores []Entrenador de animales `Grupo:" manejadores "`}función Periódico(parámetros Baramas de servidor) Servidor { // params.handlers tendrá los "controladores" de NewhelloHandler y // Nuevo EventHandler.}era Colmena = colmena.Nuevo( celúla.Proporcionar(Namhellohandler, Nuevo eventhandler, Periódico))
Para un ejemplo de trabajo de los valores grupales, verPKG/Hive/Ejemplo.
UsarProporcionar()Cuando desea exponer un objeto o una interfaz a la aplicación.Si no hay nada significativo para exponer, considere en su lugar usarInvocar()Para registrar ganchos de ciclo de vida para un objeto no exportado.
Invocar
Invoke se usa para invocar una función para inicializar alguna parte de la aplicación.Los constructores proporcionados no se llaman a menos que una función de invocación los haga referencia, ya sea directa o indirectamente a través de otro eductor:
// FUNC Invoke (funcs ... cualquier) celdacelúla.Invocar( // Construye tanto B como C y luego preséntelos entre sí. función(b B, do do) { b.Setandler(do) do.Establecer propietario(b) }, // Construye D solo para sus efectos secundarios (por ejemplo, los ganchos de inicio y parada). // Evite esto si puede y use Invoke () para registrar ganchos en lugar de proporcionar () si // No hay API para proporcionar. función(D) {},)
Módulo
Las células se pueden agrupar en módulos (un conjunto con nombre de células):
// módulo func (id, cadena de título, celdas ... celda) celdaera Celúla = celúla.Módulo( "ejemplo", // Identificador corto (para su uso en, por ejemplo, registro y rastreo) "Un módulo de ejemplo", // Descripción de una línea (para documentación) celúla.Proporcionar(Nuevo), inodoro, // Los módulos pueden contener otros módulos)era inodoro celúla.Celúla = celúla.Módulo( "Ejemplo-interno", "Un módulo interno", celúla.Proporcionar(nuevo),)
Módulo () también proporciona a las celdas envueltas unlogrus.fieldloggercon elsubsysCampo establecido en el identificador del módulo ("Ejemplo" arriba).
El alcance creado por Module () es útil cuando se combina con ResistRivate ()::
era Celúla = celúla.Módulo( "ejemplo", "Un módulo de ejemplo", celúla.Proporcionarprivate(dado), // un solo accesible desde este módulo (o submódulos) celúla.Proporcionar(Newb), // b es accesible desde cualquier lugar)
Decorar
A veces, uno puede querer usar un objeto modificado dentro de un módulo, por ejemplo, cómo el módulo anterior () proporcionó a las celdas un registrador personalizado.Esto se puede hacer con un decorador:
// FUNC Decorar (DTOR Any, células ... Cell) Cellera Celúla = celúla.Decorar( mylogger, // La función de decoración // Estas celdas verán los objetos devueltos por el decorador 'mylogger' // en lugar de los objetos en el exterior. foo.Celúla, bar.Celúla,)// mylogger es un decorador que puede depender de uno o más objetos en la aplicación// y devuelve uno o más objetos.Los parámetros de entrada no necesariamente necesitan coincidir// Los tipos de salida.función mylogger(registro logrus.Cañón de campo) logrus.Cañón de campo { devolver registro.Con campo("Láser", "aturdir")}
Configuración
Las aplicaciones de cilio usan elcobrayPflagBibliotecas para implementar la interfaz de línea de comandos.Con Cobra, uno define unDominio, con subcomcomando opcionales.Cada comando tiene un marcador asociado que debe poblarse antes de que un comando se ejecute en orden superior o para producir documentación de uso.Puentes de colmena a Cobra conCell.config, que tiene un valor que implementacelda.Para agregar banderas al flagset de un comando y retroceder una celda que "proporciona" la configuración analizada a la aplicación:
// Escriba la interfaz Flagger {// Flags (Flags *Pflag.FlagSet)//}// Config Func [CFG Flagger] (DefaultConfig CFG) Cell.Celltipo Myconfig estructura { Miopción cadena Porción []cadena Mapocion mapa[cadena]cadena}función (definición Myconfig) Banderas(banderas *Pflag.Bandera) { // Registre la bandera "my-option".Esto coincidió con el campo de miopción // eliminando cualquier guión y haciendo una comparación insensible de casos. banderas.Cadena("My-option", definición.Miopción, "Mi opción de configuración") // Los indicadores son compatibles para representar tipos complejos como cortes y mapas. // * se obtienen cortes dividiendo la cadena de entrada en las comas. // * Los mapas admiten diferentes formatos basados en cómo se proporcionan: // - CLI: Key = Formato de valor, separado por comas;La bandera puede ser // repetido varias veces. // - Variable de entorno o archivo de configuración: ya sea JSON codificado // o formato de valor separado por comisión = valor. banderas.Hilos("Opción de rebanadas", definición.Porción, "Mi opción de configuración de Slice") banderas.StringToString("Opción de mapas", definición.Mapocion, "Mi opción de configuración de mapa")}era defaultMyConfig = Myconfig{ Miopción: "El valor predeterminado",}función Nuevo(CFG Myconfig) Mythingera Celúla = celúla.Módulo( "Módulo con config", "Un módulo con una configuración", celúla.Configuración(defaultMyConfig), celúla.Proporcionar(Nuevo),)
En las pruebas, la configuración se puede poblar de varias maneras:
función Pestañas(T *pruebas.T) { H : = colmena.Nuevo(Celúla) // Las opciones se pueden configurar a través de Viper H.Víbora().Colocar("My-option", "Valor de prueba") // o a través de PFLAGS banderas : = Pflag.Nuevo(", Pflag.Continuando) H.Flags de registro(banderas) banderas.Colocar("My-option", "Valor de prueba") banderas.Analizar gramaticalmente("--my-option = test-value") // o la forma preferida con una anulación de configuración: H = colmena.Nuevo( Celúla, ) Agregar anulación de confi( H, función(CFG *Myconfig) { CFG.Miopción = "Test-Override" }) // para validar que la celda puede ser instanciada y la configuración // struct está bien formado sin comenzar, puede llamar poblado ():: si errar : = H.Poblar(); errar ! = nulo { T.Fatal("No se pudo poblar: %s", errar) }}
Métrico
La célula métrica le permite definir una colección de métricas cerca de una función que le gustaría instrumentar.Como elProporcionarcélula, define un nuevo tipo y un constructor.En el caso de una célula métrica, el tipo debe ser astructo con solo campos públicos.Los tipos de estos campos deben implementarse tantométrica.withmetadatayPrometheus.Collector. La forma más fácil de obtener tales métricas es usar los tipos definidos enPKG/Métricos/Métricos.
El tipo de estructura de colección métrica devuelta por el constructor dado es madeavilable en la colmena como un proporcionar.Además, todos los métricos disponibles a través delcolmena-metrics grupo de valores. Este grupo de valores es consumido por el paquete de métricas, por lo que cualquier métrica definidavia, una celda métrica se registra automáticamente.
era Celúla = celúla.Módulo("My-Feature", "Mi característica", celúla.Métrico(NewFeaturemetrics), celúla.Proporcionar(NewmyFeature),)tipo Feeuremetrics estructura { Llamadas métrico.VEC[métrico.Encimera] Estado latente métrico.Histograma}función NewFeaturemetrics() Feeuremetrics { devolver Feeuremetrics{ Llamadas: métrico.Newcountervec(métrico.Contraoptes{ Confirmar: métrica.Espacio de nombres + + "_my_feature_calls_total", Subsistema: "my_feature", Espacio de nombres: métrica.Espacio de nombres, Nombre: "Calls_total", }, []cadena{"llamador"}), Estado latente: métrico.Newhistogram(métrico.HISTOGRAMOPTS{ Confirmar: métrica.Espacio de nombres + + "_my_feature_latency_seconds", Espacio de nombres: métrica.Espacio de nombres, Subsistema: "my_feature", Nombre: "Latency_Seconds", }), }}tipo MyFeature estructura { métrica Feeuremetrics}función NewmyFeature(métrica Feeuremetrics) *MyFeature { devolver YMyFeature{ métrica: métrica, }}función (mf *MyFeature) Alguna función(llamador cadena) { mf.métrica.Llamadas.Con(Prometeo.Etiqueta{"llamador": llamador}).Cª() durar : = spanstat.Comenzar() // Normalmente haríamos un trabajo real aquí tiempo.Dormir(tiempo.Segundo) durar.Fin(verdadero) mf.métrica.Estado latente.Observar(durar.Artículos de segunda clase())}
Ciclo vital
Además de las células, un importante bloque de construcción en Hive es el ciclo de vida.Alifecycle es una lista de pares de gancho de inicio y parada que se ejecutan en orden (reverso al detener) al ejecutar la colmena.
paquete colmenatipo Ciclo vital { Añadir(Hookinterface)}tipo HookContext contexto.Contextotipo Hookinterface interfaz { Comenzar(HookContext) error Detener(HookContext) error}tipo Gancho estructura { En marcha función(HookContext) error En la tapa función(HookContext) error}función (H Gancho) Comenzar(CTX HookContext) error { ... }función (H Gancho) Detener(CTX HookContext) error { ... }
Los ganchos de ciclo de vida se pueden implementar implementando los métodos de Hookinterface o utilizando la estructura de gancho.El ciclo de vida es accesible desde cualquier celda:
era Examen = celúla.Módulo( "ejemplo", "Módulo de ejemplo", celúla.Proporcionar(Nuevo),)tipo Ejemplo estructura { / * ... */ }función (mi *Ejemplo) Comenzar(CTX HookContext) error { / * ... */ }función (mi *Ejemplo) Detener(CTX HookContext) error { / * ... */ }función Nuevo(LC celúla.Ciclo vital) *Ejemplo { mi : = YEjemplo{} LC.Añadir(mi) devolver mi}
Estos ganchos se ejecutan cuando se llama a Hive.run ().El HookContext que se le da a Tothese Hooks está allí para permitir el aborto elegante del inicio o la parada, ya sea debido a la presión del usuarioControl-co debido a un tiempo de espera.Por defecto, Hive tiene un tiempo de espera de inicio de 5 minutos y un tiempo de espera de parada de 1 minuto, pero estos son configurables con sattimeuts ().Se da un tiempo de gracia de 5 segundos en la parte superior del tiempo de espera que la aplicación se termina con fuerza, independientemente de si el gancho ha terminado o no.
Apagado
A veces no hay nada más que hacer más que bloquear.Si se encuentra un error fatal en unComenzar()Gancho es fácil: solo devuelve el error y aborta el inicio.Afterstoting uno puede iniciar un cierre utilizando elHive.shutdowner:
paquete colmenatipo Apagado interfaz { Cerrar(...Opción de apagado)}función Apagar con error(errar error) Opción de apagado { / * ... */ }paquete ejemplotipo Ejemplo estructura { / * ... */ Apagado colmena.Apagado}función (mi *Ejemplo) eventloop() { para { / * ... */ si errar ! = nulo { // uh oh, esto es realmente malo, tenemos que bloquear. mi.Apagado.Cerrar(colmena.Apagar con error(errar)) } }}
Crear y ejecutar una colmena
Se crea una colmena usandocolmena.new ():
// func (celdas ... celular.cell) *colmenaera myhive = colmena.Nuevo(Foocell, Barcilla)
Nuevo()Crea una nueva colmena y registra a todos los proveedores.Las invokes aún no se ejecutan, ya que nuestra aplicación puede tener múltiples colmenas y necesitamos retrasar la instancia de los objetos hasta que sepamos qué colmena usar.
Sin embargoNuevoEjecuta una función de Invoke para recopilar todos los indicadores de línea de comandos de todas las celdas de configuración.Estos pueden registrarse con un comando COBRA:
era CMD *cobra.Dominio = / * ... */myhive.Flags de registro(CMD.Banderas())
Después de eso, la colmena puede comenzar conmyhive.run ().
Run () construirá primero las configuraciones analizadas y luego ejecutará las funciones de invocar para instanciar todos los objetos necesarios.Como parte de este thelifecycle ganchs se habrá agregado (en orden de dependencia).Después de eso, los ganchos de inicio se pueden ejecutar uno tras otro para comenzar la colmena.OnCestarted, Run () espera las señales Sigterm y Sigint y al recibir Onewill ejecutar los ganchos de parada en orden inverso para derribar la colmena.
Ahora sería un buen momento para probar esto en la práctica.Encontrarás un pequeño examen en la aplicación enPKG/Hive/Ejemplo.Dirlo corriendo conir correr .y explorar la implementación (¡intente lo que sucede si se comenta un proveedor!).
Inspeccionar una colmena
Elcolmena.puede ser inspeccionado con el comando "colmena" después de que se haya registrado con Cobra:
era rootcmd *cobra.Dominio = / * ... */rootcmd.Admand(myhive.Dominio())
Cilium $ Go Run ./daemon HiveCélulas:Ⓜ️ Agente (agente de cilio):Ⓜ️ Infra (infraestructura):Ⓜ️ K8S-Client (Cliente Kubernetes):⚙️ (client.config) {Servidor de API K8S: (cadena) "",K8SKUBECONFIGPATH: (cadena) "",K8SCLIENTQPS: (Float32) 0,K8SClientBurst: (int) 0,K8S Heartbeat TimeOut: (Tiempo. Duración) 30s,Habilitark8sapidiscovery: (bool) Falso}🚧 Client.NewClientSet (Cell.go: 109):⇨ Client.Config, Cell.lifecycle, logrus.fieldlogger⇦ Client.clientetet...Start Hooks:• GOPS.RegisterGopShooks.func1 (Cell.go: 44)• cmd.newdatapath.func1 (daemon_main.go: 1625)...Stop Hooks:...
El comando Hive imprime las celdas, que muestra qué módulos, proveedores, configuraciones, etc. existen y lo que requieren y proporcionan. Finalmente, el comando imprime todos los gancos de inicio y detención registrados. Nota que estos ganchos a menudo dependen de la configuración (p. Ej.K8S-client no insertará un gancho a menos que, p.TheHive Command toma los mismos indicadores de línea de comandos que el comando root.
Las dependencias del proveedor en una colmena también se pueden visualizar como un gráfico GraphViz: Graph:
cilio $ ir correr ./demonio colmena gráfico de puntos | punto -Tx11
Pautas
Pocas pautas uno debe esforzarse por seguir al implementar células más grandes:
Una función de constructor solo debe hacer validación y asignación.El desove de las goroutinas o las operaciones de E/S no deben realizarse desde los constructores, sino más bien a través del gancho de inicio.Esto se requiere, ya que queremos inspeccionar el gráfico de ovalios (p. Ej.
colmena.printobjects) y los constructores secundarios afectarían los efectos no deseados.Las funciones de detención deben asegurarse de bloquear hasta que todos los recursos (goroutinas, manijas de archivos, ...) creados por el módulo se hayan limpiado (con p.
sync.waitgroup).Esto asegura que las pruebas independientes en el mismo conjunto de pruebas no se afecten entre sí.UsarObjetivosPara verificar que las goroutinas no se filtren.Preferiblemente, cada célula no trivial vendría con una prueba que valida que implementa su API pública correctamente.La prueba también sirve un ejemplo de cómo se usa la API de la célula y también valida la corrección de las células que depende de qué ayuda con la refactorización.
Las células de utilidad no deben invocar ().Dado que las células pueden usarse en muchas aplicaciones, tiene sentido hacerlas perezosas para permitir la agrupación de servicios útiles en una sola colección.Si una celda de servicios públicos tiene un Invoke, puede estar interesado incluso si nunca se usa.
Para células grandes, proporcione interfaces y no de estructura de punteros.Se debe pensar en un celular de proporcionar un servicio al resto de la aplicación.Tomate It Accesible, uno debe pensar en qué API proporciona el módulo y expresar estos tipos de interfaz bien documentados.Si la interfaz es grande, intente dividirla en múltiples pequeños.Los tipos de interfaz también permiten pruebas de integración con implementaciones simuladas.Lo racional aquí es lo mismo con "estructuras de retorno, aceptan interfaces": dado que Hive funciona con los nombres de los tipos, queremos "inyectar" interfaces en el gráfico de objetos y no structpointers.El beneficio adicional es que la separación de la API implementada por un módulois una o más interfaces es más fácil documentar y más fácil inspeccionar todas las declaraciones de métodos públicos están en un solo lugar.
Use objetos de parámetro (celular.in) y resultado (celular.out) liberalmente.Si AConstructor toma más de dos parámetros, considere usar un ParameterStruct en su lugar.
INTRALES: inyección de dependencia con reflexión
Hive se construye sobreUber/TU, una biblioteca basada en reflexión para los marcos de inyección de dependencia de edificios.En DIG, crea un contenedor, agrega su Constructores y luego "invoca" para crear objetos:
función dado() (A, error) { / * ... */ }función Newb() B { / * ... */ }función Tripa(A, B) (do, error) { / * ... */ }función setupc(do) error// Cree un nuevo contenedor para nuestros constructores.do : = excavar.Nuevo(excavar.Aplazamiento de la referencia())// Agregar los constructores.El orden no importa.do.Proporcionar(Tripa)do.Proporcionar(Newb)do.Proporcionar(dado)// Invocar una función que puede depender de cualquiera de los valores suministrados por el// constructores registrados.// Dado que esto depende de "C", Dig construirá primero A y B// (ya que C depende de ellos), y luego C.do.Invocar(función(do *do) { // Haz algo con C})
Esta es la base de la cual se construye Hive.Hive llama a Prov -() de Dig para cada uno de los constructores registrados con Cell.Provide y luego llaman a las funciones de Iinvoke para construir los objetos necesarios.Los resultados de los treestructores se almacenan en caché, por lo que cada constructor se llama solo una vez.
Uber/TUUtiliza el paquete "reflejar" de GO que proporciona acceso a la información del tipo de thetye de las funciones de proporcionar e invocar.Por ejemplo, elProporcionarEl método hace algo similar a esto debajo del capó:
// 'Constructor' tiene tipo "func (...) ..."tipo : = reflejar.Tipo de tono(constructor)si tipo.Amable() ! = reflejar.Función { /* error */ }en : = hacer([]reflejar.Tipo, 0, tipo.Numín())para i : = 0; i < tipo.Numín(); i++ { en[i] = tipo.En(i)}afuera : = hacer([]reflejar.Tipo, 0, tipo.Numero())para i : = 0; i < tipo.Numero(); i++ { afuera[i] = tipo.Afuera(i)}recipiente.proveedores = añadir(recipiente.proveedores, Yproveedor{constructor, en, afuera})
InvocarDe manera similar, se reflejará en el valor de la función para averiguar cuáles son las entradas requeridas y que encuentren los constructores requeridos para los objetos de entrada y recursivamente sus entradas.
Si bien construir esto en la reflexión es flexible, la desventaja es que las dependencias faltantes conducen a errores de tiempo de ejecución.Afortunadamente, DIG produce excelentes errores y sugiere tipos de objetos estrechamente coincidentes en caso de errores tipográficos.Debido al deseo, evite estos errores de tiempo de ejecución, la colmena construida debe ser lo más posible, p.El conjunto de constructores e funciones de invocación debe ser bedeterminada en el momento de la compilación y no depender de la configuración de tiempo de ejecución.Esta vía, la colmena se puede validar una vez con una prueba unitaria simple (demonio/cmd/cells_test.go).
Escaparate celular
Explotación florestal
El registro se proporciona a todas las celdas de forma predeterminada con ellogrus.fieldloggerTipo de interfaz.Las líneas de registro incluirán el camposubsys = .
celúla.Módulo( "ejemplo", "Módulo de ejemplo de registro", celúla.Proporcionar( función(registro logrus.Cañón de campo) Ejemplo { registro.Información("Hola") // subsys = ejemplo de mensaje = hola devolver Ejemplo{registro: registro} }, ),)
Cliente de Kubernetes
Elpaquete de clientesproporciona elClienteApithat combina los diferentes clientes utilizados por cilio en un valor compuesto.También proporcionaFakeclientcellPara escribir pruebas de integración para células que interactúan con el servidor de la API K8S.
era Celúla = celúla.Proporcionar(Nuevo)función Nuevo(CS cliente.Cliente) Ejemplo { devolver Ejemplo{CS: CS}}función (mi Ejemplo) Crearididentidad(identificación *ciliumv2.Identidad de cilio) error { devolver mi.CS.Ciliumv2().Identidades de cilio().Crear(mi.CTX, identificación, Metav1.CreateOptions{})}
El recurso y la tienda (ver más abajo) es la forma preferida de acceder a Kubernetes ObjectState para minimizar el tráfico al servidor API.El cliente generalmente debe usarse para crear y actualizar objetos.
Kubernetes recursos y tienda
Si bien no es una celda por sí misma,PKG/K8S/RecursoProporciona una abstracción útil para proporcionar objetos de acceso a Kubernetes basado en eventos compartidos.Implementado en la parte superior del informador de Go Go,trabajo de trabajoy almacene para codificar el patrón sugerido para los controladores de manera segura de Atype.Esta abstracción compartida proporciona una API más simple para escribir Andest y permite el control central sobre qué datos (y a qué velocidad) se extraen del servidor API y cómo se almacena (en memoria o persistida).
Los recursos generalmente están disponibles centralmente para la aplicación, por ejemplo.en cilio-agente se les proporciona dePKG/K8S/Resource.go. Vea también el ejemplo ejecutable enPKG/K8S/Resource/Ejemplo.
importar "github.com/cilium/cilium/pkg/k8s/resource"era nodescell = celúla.Proporcionar( función(LC celúla.Ciclo vital, CS cliente.Cliente) recurso.Recurso[V1.Nodo] { LW : = tensiones.ListerWatcherFromTyped[*V1.Nodo] (CS.Corev1().Nodos()) devolver recurso.Nuevo[*V1.Nodo] (LC, LW) },)era Celúla = celúla.Módulo( "Ejemplo de recursos", "Ejemplo de cómo usar el recurso", nodescell, celúla.Invocar(printnodeupdates),)función printnodeupdates(nodos recurso.Recurso[*V1.Nodo]) { // store () Devuelve un almacén de objetos tipificado localmente de los objetos. // Esta llamada bloquea hasta que la tienda se haya sincronizado. almacenar, errar : = nodos.Almacenar() ... obj, existe, errar : = almacenar.Conseguir("My-nodo") ... objs, errar : = almacenar.Lista() ... // eventos () Devuelve un canal de eventos de cambio de objeto.Cierre // Cuando se cancela 'CTX'. // Escriba el evento [t] struct {Kind Kind;Clave clave;Objeto t;Funce Func (error err)} para eV : = rango nodos.Eventos(CTX) { cambiar eV.Amable { caso recurso.Sincronización: // La tienda ahora se ha sincronizado con API-servidor y // El conjunto de eventos upsert observados forma un coherente // instantánea.Por lo general, algún tipo de recolección de basura o // se realiza la reconciliación. caso recurso.Upsert: fmt.Printf("El nodo %s ha actualizado: %v \ n", eV.Llave, eV.Objeto) caso recurso.Borrar: fmt.Printf("El nodo %s se ha eliminado \ n", llave) } // Cada evento debe marcarse como se maneja.Si un error no nulo // se da, el procesamiento de esta clave se vuelve a jugar más tarde // Según la política de limitación de tasas y reintentos.El incorporado // El volver a intentar a menudo se usa si realizamos operaciones de E/S (como API Client // llamadas) del controlador y el reintento tiene sentido.No debería // se utilizará en errores de análisis y similares. eV.Hecho(nulo) }}
Grupos de trabajo
Elpaquete de trabajoContiene una lógica que facilita la administración de unidades de trabajo a las que el paquete se refiere como "trabajos".Estos trabajos están programados como parte de un grupo de trabajo.
Cada trabajo es una función de devolución de llamada proporcionada por el usuario con una lógica adicional que se dedica ligeramente a cada tipo de trabajo.Los trabajos y los grupos manejan gran parte de la gestión del ciclo de vida de los horarios.Las devoluciones de llamada se llaman desde el trabajo para realizar el trabajo real.
Estos trabajos mismos vienen en varias variedades.ElOtroJob invoca su devolución de llamada solo una vez. Este tipo de trabajo se puede utilizar para la inicialización después del inicio de la celda, rutinas que se ejecutan para el ciclo de vida completo de la celda, o para cualquier otra tarea para la que normalmente usaría una Goroutine simple.
ElMinuteroJob invoca su devolución de llamada periódicamente.Este tipo de trabajo se puede utilizar para tareas periódicas como sincronización o recolección de basura.Los trabajos del temporizador también pueden activarse externamente a la inadición a las invocaciones periódicas.
ElObservadorEl trabajo invoca su devolución de llamada para cada mensaje enviado en untransmisión. Observable.Este tipo de trabajo se puede usar para reaccionar a un flujo de datos o eventos creados por otras celdas.
Por favor, eche un vistazo aPKG/Hive/Ejemplos/Jobs.GoPara un ejemplo de cómo usar el paquete de trabajo.
