go debian packaging

Aplicación Packaging Go para Debian



(5)

Acabo de investigar esto yo mismo, y básicamente estoy allí.

Sinopsis

Al ''tomar prestado'' de la rama ''paquete'' de uno de los proyectos Go existentes de Canonical, puede construir su paquete con dpkg-buildpackage.

  1. instalar dependencias y tomar una rama ''paquete'' de otro repositorio.

    # I think this list of packages is enough. May need dpkg-dev aswell. sudo apt-get install bzr debhelper build-essential golang-go bzr branch lp:~niemeyer/cobzr/package mypackage-build cd mypackage-build

  2. Edite los metadatos.

    • edite el archivo debian / control (nombre, versión, fuente). Es posible que necesite cambiar la dependencia estable de golang a golang-go.
    • El archivo debian/control es el manifiesto. Tenga en cuenta las ''dependencias de compilación'' ( Build-Depends: debhelper (>= 7.0.50~), golang-stable ) y las 3 arquitecturas. Utilizando Ubuntu (sin los gophers ppa), tuve que cambiar golang-stable a golang-go.
    • edite el archivo debian / rules (ponga su nombre de paquete en lugar de cobzr).
    • El archivo debian/rules es básicamente un archivo ''make'' y muestra cómo se compila el paquete. En este caso, dependen en gran medida de Debhelper. Aquí configuraron GOPATH e invocaron ''ir a instalar''. Aquí está la mágica línea de ''ir a instalar'':

    cd $(GOPATH)/src && find * -name ''*.go'' -exec dirname {} /; | xargs -n1 go install

    • También actualice el archivo de derechos de autor, el archivo Léame, la licencia, etc.

  3. Coloque su fuente dentro de la carpeta src. p.ej

    git clone https://github.com/yourgithubusername/yourpackagename src/github.com/yourgithubusername/yourpackagename

    o eg2

    cp .../yourpackage/ src/

  4. construye el paquete

    # -us -uc skips package signing. dpkg-buildpackage -us -uc

    Esto debería producir un archivo .deb binario para su arquitectura, más el ''deb de origen'' (.tgz) y el archivo de descripción de deb fuente (.dsc).

Más detalles

Entonces, me di cuenta de que Canonical (la gente de Ubuntu) usa Go y crea paquetes .deb para algunos de sus proyectos de Go. Ubuntu se basa en Debian, por lo que en su mayor parte el mismo enfoque debería aplicarse a ambas distribuciones (los nombres de dependencia pueden variar ligeramente).

Encontrará algunos paquetes basados ​​en Go en los repositorios Launchpad de Ubuntu. Hasta ahora he encontrado cobzr (ramificación git-style para bzr) y juju-core (un proyecto devops, siendo portado desde Python).

Ambos proyectos tienen una rama ''troncal'' y ''paquete'', y usted puede ver la carpeta debian/ dentro de la rama del paquete. Los 2 archivos más importantes aquí son debian/control y debian/rules - He vinculado a ''browse source''.

Finalmente

Algo que no he cubierto es la compilación cruzada de su paquete (a las otras 2 arquitecturas de 3, 386 / arm / amd64). La compilación cruzada no es demasiado complicada (tienes que construir la cadena de herramientas para cada plataforma de destino, y luego establecer algunas variables ENV durante ''ir a compilar''), y he estado trabajando en una utilidad de compilación cruzada. Eventualmente, espero agregar el soporte de .deb a mi utilidad, pero primero necesito cristalizar esta tarea.

Buena suerte. Si progresas, actualiza mi respuesta o agrega un comentario. Gracias

¿Cómo puedo poner mi binario Go en un paquete Debian? Como Go está vinculado estáticamente, solo tengo un ejecutable único: no necesito mucha información complicada de metadatos del proyecto. ¿Existe una forma simple de empaquetar los archivos ejecutables y de recursos sin pasar por el trauma de debuild ?

Revisé todas las preguntas existentes; sin embargo, toda mi investigación arroja preguntas / respuestas sobre un archivo .deb que contiene el entorno de desarrollo de golang (es decir, lo que obtendría si lo hace sudo apt-get install golang-go ).

Bien. Creo que el único "trauma" de debuild es que ejecuta lintian después de lintian el paquete, y es lintian quien intenta detectar problemas con tu paquete.

Entonces hay dos formas de combatir la situación:

  • No use debuild : esta herramienta simplemente llama a dpkg-buildpackage que realmente hace el powerlifting necesario. La llamada habitual para compilar un paquete binario es dpkg-buildpackage -us -uc -b . Aún puede llamar a debuild para otros fines, como debuild clean por ejemplo.
  • Agregue la llamada "anulación lintian" que se puede usar para hacer que lintian haga la vista gorda a los problemas seleccionados con su paquete que, insiste, no son problemas.

Ambos enfoques implican que no intente construir su aplicación con las herramientas de empaque, sino más bien tratarla como un blob que simplemente está envuelto en un paquete. Esto requeriría un poco de abstracción de la manera normal en que funciona debian/rules (para no intentar construir nada).

Otra solución que podría ser posible (y es realmente mucho más Debian-ish) es tratar de usar gcc-go (más gold para vincular): dado que es un front end GCC, esta herramienta produce una aplicación vinculada dinámicamente (que enlaza contra libgo o algo como esto). Yo, personalmente, aún no tengo experiencia, y solo consideraría usarlo si tiene la intención de introducir su paquete en el Debian propiamente dicho.

Con respecto a la cuestión general del empaquetado de los programas Go para Debian, es posible que encuentre útiles los siguientes recursos:

  • Este hilo comenzó en go-nuts por uno de los empaquetadores de Debian para Debian.
  • En particular, la primera publicación en ese hilo se vincula a esta discusión en debian-devel.
  • El segundo hilo en debian-devel con respecto al mismo problema (es una continuación lógica del hilo anterior).

Actualización el 15-10-2015.

(Debido a que esta publicación parece ser aún buscada y encontrada y estudiada por personas, he decidido actualizarla para reflejar mejor el estado actual de las cosas).

Desde entonces, la situación con el paquete de aplicaciones y paquetes Go se mejoró de forma espectacular, y es posible crear un paquete Debian utilizando Go "clásico" (el llamado conjunto de gc originario de Google) en lugar de gcc-go . Y existe una buena infraestructura para paquetes también.

La herramienta clave para usar al debianizar un programa Go ahora es dh-golang describe here .

Crear paquetes de deb o rpm desde Go Applications también es muy fácil con fpm.

Cógelo de rubygems:

gem install fpm

Después de compilarlo binario, por ejemplo, foobar, puede empaquetarlo así:

fpm -s dir -t deb -n foobar -v 0.0.1 foobar=/usr/bin/

fpm admite todo tipo de opciones avanzadas de empaquetado.

Existe un documento de política oficial de Debian que describe el procedimiento de empaquetado de Go: https://go-team.pages.debian.net/packaging.html

Para bibliotecas : use dh-make-golang para crear un esqueleto de paquete. Nombre su paquete con un nombre derivado de la ruta de importación, con un sufijo -dev , por ejemplo, golang-github-lib-pq-dev. Especifique las dependencias ont Depends: line. (Estas son dependencias de origen para compilar, no dependencias binarias para ejecutarse, ya que Go vincula estáticamente todas las fuentes).

La instalación del paquete de la biblioteca instalará su código fuente en /usr/share/golang/src (posiblemente, las librerías compiladas puedan entrar en .../pkg ). Los paquetes Go dependientes del edificio usarán los artefactos de esas ubicaciones de todo el sistema.

Para ejecutables : use dh-golang para crear el paquete. Especifique las dependencias en Build-Depends: line (consulte más arriba sobre el empaquetado de las dependencias).

Recientemente descubrí https://packager.io/ - Estoy bastante contento con lo que están haciendo. Tal vez abrir uno de los paquetes para ver lo que están haciendo?