Merge branch 'master' into master

pull/84/head
Kyle Quest 4 years ago committed by GitHub
commit afdfc42ca7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -0,0 +1,22 @@
root = true
[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
[{*.go,Makefile,.gitmodules,go.mod,go.sum}]
indent_style = tab
[*.md]
indent_style = tab
trim_trailing_whitespace = false
[*.{yml,yaml,json}]
indent_style = space
indent_size = 2
[*.{js,jsx,ts,tsx,css,less,sass,scss,vue,py}]
indent_style = space
indent_size = 4

@ -6,6 +6,7 @@ Translations:
* [简体中文](README_zh.md)
* [Français](README_fr.md)
* [正體中文](README_zh-TW.md)
* [日本語](README_ja.md)
## Overview
@ -178,16 +179,19 @@ Don't confuse the project level `/src` directory with the `/src` directory Go us
* [Go Report Card](https://goreportcard.com/) - It will scan your code with `gofmt`, `go vet`, `gocyclo`, `golint`, `ineffassign`, `license` and `misspell`. Replace `github.com/golang-standards/project-layout` with your project reference.
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-standards/project-layout?style=flat-square)](https://goreportcard.com/report/github.com/golang-standards/project-layout)
* ~~[GoDoc](http://godoc.org) - It will provide online version of your GoDoc generated documentation. Change the link to point to your project.~~
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/golang-standards/project-layout)
* [Pkg.go.dev](https://pkg.go.dev) - Pkg.go.dev is a new destination for Go discovery & docs. You can create a badge using the [badge generation tool](https://pkg.go.dev/badge).
[![PkgGoDev](https://pkg.go.dev/badge/github.com/golang-standards/project-layout)](https://pkg.go.dev/github.com/golang-standards/project-layout)
* Release - It will show the latest release number for your project. Change the github link to point to your project.
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-standards/project-layout?style=flat-square)](https://goreportcard.com/report/github.com/golang-standards/project-layout)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/golang-standards/project-layout)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/golang-standards/project-layout)](https://pkg.go.dev/github.com/golang-standards/project-layout)
[![Release](https://img.shields.io/github/release/golang-standards/project-layout.svg?style=flat-square)](https://github.com/golang-standards/project-layout/releases/latest)
[![Release](https://img.shields.io/github/release/golang-standards/project-layout.svg?style=flat-square)](https://github.com/golang-standards/project-layout/releases/latest)
## Notes

@ -0,0 +1,194 @@
# Standard Go Project Layout
Traducciones:
* [한국어 문서](README_ko.md)
* [中文文档](README_zh.md)
* [Français](README_fr.md)
* [Español](README_es.md)
## Resumen
Este es un diseño básico para proyectos de aplicaciones de Go. No es un estándar oficial definido por el equipo de desarrollo principal de Go; sin embargo, es un conjunto de patrones de diseño de proyectos históricos y emergentes comunes en el ecosistema Go. Algunos de estos patrones son más populares que otros. También tiene una serie de pequeñas mejoras junto con varios directorios de soporte comunes a cualquier aplicación del mundo real lo suficientemente grande.
Si está tratando de aprender Go o si está construyendo un PoC o un proyecto de juguete para usted, este diseño del proyecto es excesivo. Comience con algo realmente simple (un solo archivo `main.go` es más que suficiente). A medida que su proyecto crezca, tenga en cuenta que será importante asegurarse de que su código esté bien estructurado, de lo contrario, terminará con un código desordenado con muchas dependencias ocultas y un estado global. Cuando tenga más personas trabajando en el proyecto, necesitará aún más estructura. Ahí es cuando es importante introducir una forma común de administrar paquetes / bibliotecas. Cuando tienes un proyecto de código abierto o cuando sabes que otros proyectos importan el código del repositorio de tu proyecto, es cuando es importante tener paquetes y código privados (también conocidos como `internal`). ¡Clona el repositorio, guarda lo que necesitas y elimina todo lo demás! El hecho de que esté allí no significa que tenga que usarlo todo. Ninguno de estos patrones se utiliza en todos los proyectos. Incluso el patrón `vendor` no es universal.
Con Go 1.14, [`los módulos Go`](https://github.com/golang/go/wiki/Modules) están finalmente listos para la producción. Use [`los módulos Go`](https://blog.golang.org/using-go-modules) a menos que tenga una razón específica para no usarlos y, si lo hace, no debe preocuparse por $ GOPATH y dónde coloque su proyecto. El archivo `go.mod` básico en el repositorio asume que su proyecto está alojado en GitHub, pero no es un requisito. La ruta del módulo puede ser cualquier cosa, aunque el primer componente de la ruta del módulo debe tener un punto en su nombre (la versión actual de Go ya no lo aplica, pero si está utilizando versiones un poco más antiguas, no se sorprenda si sus compilaciones fallan sin eso). Consulte los problemas [`37554`](https://github.com/golang/go/issues/37554) y [`32819`](https://github.com/golang/go/issues/32819) si desea obtener más información al respecto.
Este diseño de proyecto es intencionalmente genérico y no intenta imponer una estructura de paquete Go específica.
Este es un esfuerzo comunitario. Abra un problema si ve un patrón nuevo o si cree que uno de los patrones existentes debe actualizarse.
Si necesita ayuda con el nombre, el formato y el estilo, comience ejecutando `gofmt` y `golint`. También asegúrese de leer estas recomendaciones y pautas de estilo del código Go:
* https://talks.golang.org/2014/names.slide
* https://golang.org/doc/effective_go.html#names
* https://blog.golang.org/package-names
* https://github.com/golang/go/wiki/CodeReviewComments
* [Guía de estilo para paquetes Go](https://rakyll.org/style-packages) (rakyll/JBD)
Consulte [`Diseño de proyecto de Go`](https://medium.com/golang-learn/go-project-layout-e5213cdcfaa2) para obtener información adicional sobre los antecedentes.
Más sobre cómo nombrar y organizar paquetes, así como otras recomendaciones de estructura de código:
* [GopherCon EU 2018: Peter Bourgon - Best Practices for Industrial Programming](https://www.youtube.com/watch?v=PTE4VJIdHPg)
* [GopherCon Russia 2018: Ashley McNamara + Brian Ketelsen - Go best practices.](https://www.youtube.com/watch?v=MzTcsI6tn-0)
* [GopherCon 2017: Edward Muller - Go Anti-Patterns](https://www.youtube.com/watch?v=ltqV6pDKZD8)
* [GopherCon 2018: Kat Zien - How Do You Structure Your Go Apps](https://www.youtube.com/watch?v=oL6JBUk6tj0)
Una publicación en idioma chino sobre las pautas de diseño orientado a paquetes y la capa de arquitectura
* [面向包的设计和架构分层](https://github.com/danceyoung/paper-code/blob/master/package-oriented-design/packageorienteddesign.md)
## Directorios en Go
### `/cmd`
Principales aplicaciones de este proyecto.
El nombre del directorio de cada aplicación debe coincidir con el nombre del ejecutable que desea tener (p.ej, `/cmd/myapp`).
No pongas mucho código en el directorio de la aplicación. Si cree que el código se puede importar y utilizar en otros proyectos, entonces debería residir en el directorio `/pkg`. Si el código no es reutilizable o si no desea que otros lo reutilicen, coloque ese código en el directorio `/internal`. Se sorprenderá de lo que harán los demás, ¡así que sea explícito sobre sus intenciones!
Es común tener una pequeña función `main` que importa e invoca el código de los directorios `/internal` y `/pkg` y nada más.
Consulte el directorio [`/cmd`](cmd/README.md) para ver ejemplos.
### `/internal`
Aplicación privada y código de biblioteca. Este es el código que no desea que otros importen en sus aplicaciones o bibliotecas. Tenga en cuenta que el propio compilador de Go aplica este patrón de diseño. Consulte [`las notas de la versión`](https://golang.org/doc/go1.4#internalpackages) Go 1.4 para obtener más detalles. Tenga en cuenta que no está limitado al directorio `internal` de nivel superior. Puede tener más de un directorio `internal` en cualquier nivel del árbol de su proyecto.
Opcionalmente, puede agregar un poco de estructura adicional a sus paquetes internos para separar su código interno compartido y no compartido. No es necesario (especialmente para proyectos más pequeños), pero es bueno tener pistas visuales que muestren el uso previsto del paquete. Su código de aplicación real puede ir en el directorio `/internal/app` (p.ej, `/internal/app/myapp`) y el código compartido por esas aplicaciones en el directorio `/internal/pkg` (por ejemplo, `/internal/pkg/myprivlib`).
### `/pkg`
Código de biblioteca que puede usar aplicaciones externas (por ejemplo, `/pkg/mypubliclib`). Otros proyectos importarán estas bibliotecas esperando que funcionen, así que piénselo dos veces antes de poner algo aquí :-) Tenga en cuenta que el directorio `internal` es la mejor manera de asegurarse de que sus paquetes privados no se puedan importar porque Go lo aplica. El directorio `/pkg` sigue siendo una buena forma de comunicar explícitamente que el código de ese directorio es seguro para que lo utilicen otros. La publicación del blog de Travis Jeffery, [`I'll take pkg over internal`](https://travisjeffery.com/b/2019/11/i-ll-take-pkg-over-internal/), proporciona una buena descripción de los directorios `pkg` e `internal` y de cuándo podría tener sentido usarlos.
También es una forma de agrupar el código de Go en un solo lugar cuando su directorio raíz contiene muchos componentes y directorios que no son de Go, lo que facilita la ejecución de varias herramientas de Go (como se menciona en estas charlas: [`Best Practices for Industrial Programming`](https://www.youtube.com/watch?v=PTE4VJIdHPg) de GopherCon EU 2018, [GopherCon 2018: Kat Zien - How Do You Structure Your Go Apps](https://www.youtube.com/watch?v=oL6JBUk6tj0) y [GoLab 2018 - Massimiliano Pippi - Project layout patterns in Go](https://www.youtube.com/watch?v=3gQa1LWwuzk)).
Consulte el directorio [`/pkg`](pkg/README.md) si desea ver qué repositorios Go populares utilizan este patrón de diseño de proyecto. Este es un patrón de diseño común, pero no se acepta universalmente y algunos miembros de la comunidad de Go no lo recomiendan.
Está bien no usarlo si el proyecto de su aplicación es realmente pequeño y donde un nivel adicional de anidamiento no agrega mucho valor (a menos que realmente quiera :-)). Piénselo cuando sea lo suficientemente grande y su directorio raíz esté bastante ocupado (especialmente si tiene muchos componentes de aplicaciones que no son de Go).
### `/vendor`
Dependencias de aplicaciones (administradas manualmente o mediante su herramienta de administración de dependencias favorita, como la nueva función de [`Módulos Go`](https://github.com/golang/go/wiki/Modules) integrada). El comando `go mod vendor` creará el directorio `/vendor` por usted. Tenga en cuenta que es posible que deba agregar la marca `-mod=vendor` a su comando `go build` si no está usando Go 1.14 donde está activado de forma predeterminada.
No adicione las dependencias de su aplicación si está creando una biblioteca.
Tenga en cuenta que desde [`1.13`](https://golang.org/doc/go1.13#modules) Go también habilitó la función de proxy del módulo (utilizando [`https://proxy.golang.org`](https://proxy.golang.org) como su servidor proxy del módulo de forma predeterminada). Lea más sobre esto [`aquí`](https://blog.golang.org/module-mirror-launch) para ver si se ajusta a todos sus requisitos y limitaciones. Si es así, no necesitará el directorio `vendor` en absoluto.
## Directorios de Aplicaciones de Servicio
### `/api`
Especificaciones de OpenAPI/Swagger, archivos de esquema JSON, archivos de definición de protocolo.
Consulte el directorio [`/api`](api/README.md) para ver ejemplos.
## Directorios de Aplicaciones Web
### `/web`
Componentes específicos de la aplicación web: activos web estáticos, plantillas del lado del servidor y SPAs.
## Directorios de aplicaciones comunes
### `/configs`
Plantillas de archivos de configuración o configuraciones predeterminadas.
Ponga aquí sus archivos de plantilla `confd` o `consul-template`.
### `/init`
Configuraciones de inicio del sistema (systemd, upstart, sysv) y administración de procesos (runit, supervisord).
### `/scripts`
Scripts para realizar varias operaciones de construcción, instalación, análisis, etc.
Estos scripts mantienen el Makefile de nivel raíz pequeño y simple (p.ej, [`https://github.com/hashicorp/terraform/blob/master/Makefile`](https://github.com/hashicorp/terraform/blob/master/Makefile)).
Consulte el directorio `/scripts` para ver ejemplos.
### `/build`
Empaquetado e Integración Continua.
Coloque sus configuraciones de paquetes de nube (AMI), contenedor (Docker), SO (deb, rpm, pkg) y scripts en el directorio `/build/package`.
Coloque sus configuraciones y scripts de CI (travis, circle, drone) en el directorio `/build/ci`. Tenga en cuenta que algunas de las herramientas de CI (p.ej, Travis CI) son muy exigentes con la ubicación de sus archivos de configuración. Intente poner los archivos de configuración en el directorio `/build/ci` vinculándolos a la ubicación donde las herramientas de CI los esperan (cuando sea posible).
### `/deployments`
Configuraciones y plantillas de implementación de IaaS, PaaS, sistema y orquestación de contenedores (docker-compose, kubernetes/helm, mesos, terraform, bosh). Tenga en cuenta que en algunos repositorios (especialmente las aplicaciones implementadas con kubernetes) este directorio se llama `/deploy`.
### `/test`
Aplicaciones de prueba externas adicionales y datos de prueba. Siéntase libre de estructurar el directorio `/test` como desee. Para proyectos más grandes, tiene sentido tener un subdirectorio de datos. Por ejemplo, puede tener `/test/data` o `/test/testdata` si necesita Go para ignorar lo que hay en ese directorio. Tenga en cuenta que Go también ignorará los directorios o archivos que comiencen con "." o "_", por lo que tiene más flexibilidad en términos de cómo nombrar su directorio de datos de prueba.
Consulte el directorio [`/test`](test/README.md) para ver ejemplos.
## Otros Directorios
### `/docs`
Diseño y documentos de usuario (además de su documentación generada por godoc).
Consulte el directorio [`/docs`](docs/README.md) para ver ejemplos.
### `/tools`
Herramientas de apoyo para este proyecto. Tenga en cuenta que estas herramientas pueden importar código de los directorios `/pkg` y `/internal`.
Consulte el directorio [`/tools`](tools/README.md) para ver ejemplos.
### `/examples`
Ejemplos para sus aplicaciones y / o bibliotecas públicas.
Consulte el directorio [`/examples`](examples/README.md) para ver ejemplos.
### `/third_party`
Herramientas de ayuda externas, código bifurcado y otras utilidades de terceros (p.ej, Swagger UI).
### `/githooks`
Ganchos de Git.
### `/assets`
Otros activos que acompañan a su repositorio (imágenes, logotipos, etc.).
### `/website`
Este es el lugar para colocar los datos del sitio web de su proyecto si no está utilizando GitHub pages.
Consulte el directorio [`/website`](website/README.md) para ver ejemplos.
## Directorios que No Deberías Tener
### `/src`
Algunos proyectos de Go tienen una carpeta `src`, pero suele ocurrir cuando los desarrolladores vienen del mundo Java, donde es un patrón común. Si puede ayudarse a sí mismo, intente no adoptar este patrón de Java. Realmente no quieres que tu código Go o proyectos Go se parezcan a Java :-)
No confunda el directorio `/src` de nivel de proyecto con el directorio `/src` que usa Go para sus áreas de trabajo, como se describe en [`How to Write Go Code`](https://golang.org/doc/code.html). La variable de entorno `$GOPATH` apunta a su área de trabajo (actual) (de forma predeterminada apunta a `$HOME/go` en sistemas que no son Windows). Este espacio de trabajo incluye los directorios de nivel superior `/pkg`, `/bin` y `/src`. Su proyecto real termina siendo un subdirectorio en `/src`, por lo que si tiene el directorio `/src` en su proyecto, la ruta del proyecto se verá así: `/some/path/to/workspace/src/your_project/src/your_code.go`. Tenga en cuenta que con Go 1.11 es posible tener su proyecto fuera de su `GOPATH`, pero aún así no significa que sea una buena idea utilizar este patrón de diseño.
## Badges
* [Go Report Card](https://goreportcard.com/) - Escaneará su código con `gofmt`, `go vet`, `gocyclo`, `golint`, `ineffassign`, `license` y `misspell`. Cambie `github.com/golang-standards/project-layout` por la referencia de su proyecto.
* ~~[GoDoc](http://godoc.org) - Proporcionará una versión en online de su documentación generada por GoDoc. Cambie el enlace para que apunte a su proyecto.~~
* [Pkg.go.dev](https://pkg.go.dev) - Pkg.go.dev es un nuevo destino para Go discovery & docs. Puede crear una insignia con [la herramienta de generación de insignias](https://pkg.go.dev/badge).
* Release - mostrará el número de versión más reciente de su proyecto. Cambie el enlace de github para que apunte a su proyecto.
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-standards/project-layout?style=flat-square)](https://goreportcard.com/report/github.com/golang-standards/project-layout)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/golang-standards/project-layout)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/golang-standards/project-layout)](https://pkg.go.dev/github.com/golang-standards/project-layout)
[![Release](https://img.shields.io/github/release/golang-standards/project-layout.svg?style=flat-square)](https://github.com/golang-standards/project-layout/releases/latest)
## Notas
Una plantilla de proyecto con mayor criterio sobre configuraciones, scripts y códigos de ejemplos está en construcción (WIP).

@ -6,6 +6,7 @@ Traductions:
* [简体中文](README_zh.md)
* [Français](README_fr.md)
* [正體中文](README_zh-TW.md)
* [日本語](README_ja.md)
## Introduction

@ -0,0 +1,194 @@
# Standard Go Project Layout
翻訳:
* [한국어 문서](README_ko.md)
* [中文文档](README_zh.md)
* [Français](README_fr.md)
* [日本語](README_ja.md)
## 概要
これは、Goアプリケーションプロジェクトの基本的なレイアウトです。これは、コアとなるGo開発チームによって定義された公式の標準ではありませんが、Goエコシステムの中で、歴史的に共通しているプロジェクトのレイアウトパターンのセットとなっています。これらのパターンの中には、他のパターンよりも人気のあるものもあります。また、現実世界の大規模なアプリケーションに共通するいくつかのサポートディレクトリに加えて、いくつかの小さな機能強化が行われています。
Goを学ぼうとしている場合や、自分でPoCやおもちゃのプロジェクトを構築しようとしている場合、このプロジェクトレイアウトはやりすぎです。最初は本当にシンプルなものから始めてください`main.go`ファイルが1つあれば十分です。プロジェクトが大きくなるにつれて、コードが適切に構造化されているかどうかが重要になることに注意してください。そうしないと、多くの隠れた依存関係やグローバルな状態を持つ厄介なコードになってしまいます。プロジェクトで作業する人が増えれば、さらに多くの構造が必要になります。そこで、パッケージやライブラリを管理するための共通の方法を導入することが重要になります。オープンソースプロジェクトがある場合や、他のプロジェクトがプロジェクトリポジトリからコードをインポートしていることを知っている場合は、プライベートな(内部的な)パッケージやコードを持つことが重要になります。リポジトリをクローンして、必要なものだけを残し、他のものはすべて削除してください。リポジトリにあるからといって、すべてを使わなければならないわけではありません。これらのパターンはすべてのプロジェクトで使われているわけではありません。`vendor`パターンでさえも、万能ではありません。
Go 1.14では、[`Go Modules`](https://github.com/golang/go/wiki/Modules)がついに本番に向けて準備が整いました。使用しない特別な理由がない限り、[`Go Modules`](https://blog.golang.org/using-go-modules) を使用してください。もし使用するのであれば、$GOPATH やプロジェクトをどこに置くかを気にする必要はありません。レポの基本的な `go.mod` ファイルは、プロジェクトが GitHub でホストされていることを前提としていますが、必須ではありません。モジュールパスは何でも構いませんが、最初のモジュールパスコンポーネントの名前にはドットを付けてください (現在の Go のバージョンではもうこれを強制していませんが、少し古いバージョンを使っているのであれば、これを付けなくてもビルドが失敗しても驚かないでください)。これについて詳しく知りたい場合は、Issue [`37554`](https://github.com/golang/go/issues/37554) と [`32819`](https://github.com/golang/go/issues/32819) を参照してください。
このプロジェクトは意図的に一般的なレイアウトを使用しており、特定のGoパッケージを押し付けているわけではありません。
これはコミュニティの取り組みです。 新しいパターンが表示された場合、または既存のパターンの1つを更新する必要があると思われる場合は、issueで起票してください。
名前付け、フォーマット、スタイルについてサポートが必要な場合は、[`gofmt`](https://golang.org/cmd/gofmt/)と[`golint`](https://github.com/golang/lint)を実行することから始めます。また、次のGoコードスタイルのガイドラインと推奨事項も必ずお読みください:
* https://talks.golang.org/2014/names.slide
* https://golang.org/doc/effective_go.html#names
* https://blog.golang.org/package-names
* https://github.com/golang/go/wiki/CodeReviewComments
* [Style guideline for Go packages](https://rakyll.org/style-packages) (rakyll/JBD)
追加の背景情報については、[`Go Project Layout`](https://medium.com/golang-learn/go-project-layout-e5213cdcfaa2)を参照してください。
パッケージの命名と整理、およびその他のコード構造の推奨事項の詳細:
* [GopherCon EU 2018: Peter Bourgon - Best Practices for Industrial Programming](https://www.youtube.com/watch?v=PTE4VJIdHPg)
* [GopherCon Russia 2018: Ashley McNamara + Brian Ketelsen - Go best practices.](https://www.youtube.com/watch?v=MzTcsI6tn-0)
* [GopherCon 2017: Edward Muller - Go Anti-Patterns](https://www.youtube.com/watch?v=ltqV6pDKZD8)
* [GopherCon 2018: Kat Zien - How Do You Structure Your Go Apps](https://www.youtube.com/watch?v=oL6JBUk6tj0)
パッケージ指向の設計ガイドラインとアーキテクチャレイヤーに関する中国の投稿
* [パッケージ指向の設計とアーキテクチャの階層化](https://github.com/danceyoung/paper-code/blob/master/package-directiond-design/packagedirectioneddesign.md)
## Goのディレクトリ
### `/cmd`
このプロジェクトの主なアプリケーション。
各アプリケーションのディレクトリ名は、欲しい実行ファイルの名前と一致するようにしてください(例: `/cmd/myapp`)。
アプリケーションディレクトリには多くのコードを入れないようにしましょう。コードをインポートして他のプロジェクトで使えると思うならば、`/pkg`ディレクトリに置くべきです。コードが再利用できない場合や、他の人に再利用してほしくない場合は、そのコードを`/internal`ディレクトリに置いてください。他の人が何をするか驚くでしょうから、自分の意図を明確にしてください。
このような場合は、`/internal`ディレクトリと`/pkg`ディレクトリからコードをインポートして呼び出す小さなメイン関数を持つのが一般的ですが、それ以外は何もしません。
例に関しては、[`/cmd`](cmd/README.md)ディレクトリを参照してください。
### `/internal`
プライベートなアプリケーションやライブラリのコード。これは、他の人が自分のアプリケーションやライブラリにインポートしたくないコードです。このレイアウトパターンは、Goコンパイラによって強制されることに注意してください。詳細については、Go 1.4の[`リリースノート`](https://golang.org/doc/go1.4#internalpackages)を参照してください。トップレベルの内部ディレクトリに限定されないことに注意してください。プロジェクトツリーのどのレベルでも、複数の内部ディレクトリを持つことができます。
オプションで、内部パッケージに少し余分な構造を追加して、共有内部コードと非共有内部コードを分離することができます。(特に小規模なプロジェクトでは) 必須ではありませんが、パッケージの使用目的を示す視覚的な手がかりがあるのは良いことです。実際のアプリケーションコードは `/internal/app` ディレクトリ (例: `/internal/app/myapp`) に、それらのアプリケーションで共有されるコードは `/internal/pkg` ディレクトリ (例: `/internal/pkg/myprivlib`) に置くことができます。
### `/pkg`
外部アプリケーションで使用しても問題ないライブラリコード(例: `/pkg/mypubliclib`)。他のプロジェクトは、これらのライブラリが動作することを期待してインポートしますので、ここに何かを置く前によく考えてください :-)。内部ディレクトリは、プライベートパッケージがインポートできないようにするためのより良い方法であることに注意してください。`/pkg` ディレクトリは、そのディレクトリにあるコードが他の人に使われても安全であることを明示的に伝える良い方法です。[`I'll take pkg over internal blog post by Travis Jeffery`](https://travisjeffery.com/b/2019/11/i-ll-take-pkg-over-internal/) は、`pkg` ディレクトリと内部ディレクトリの概要と、それらを使用することが意味のある場合の概要を提供しています。
また、ルートディレクトリにGo以外のコンポーネントやディレクトリが多数含まれている場合は、Goコードを1つの場所にグループ化して、さまざまなGoツールを簡単に実行できるようにする方法でもありますこれらの講演で言及されているように[`産業用プログラミングのベストプラクティス`](https //www.youtube.com/watchv = PTE4VJIdHPg) from GopherCon EU 2018、[`GopherCon 2018Kat Zien-How Do You Structure Your Go Apps`](https://www.youtube.com/watch?v= oL6JBUk6tj0) および [`GoLab 2018-Massimiliano Pippi-Goのプロジェクトレイアウトパターン`](https://www.youtube.com/watch?v=3gQa1LWwuzk))。
このプロジェクトレイアウトパターンを使用している人気のある Go repos を見たい場合は [`/pkg`](pkg/README.md) ディレクトリを参照してください。これは一般的なレイアウトパターンですが、普遍的に受け入れられているわけではありませんし、Goコミュニティの中には推奨していない人もいます。
アプリプロジェクトが非常に小さく、追加レベルのネストがあまり価値をもたらさない場合は、使用しないでください(本当に必要な場合を除く:-))。 それが十分に大きくなり、ルートディレクトリがかなり肥大化してきたときに考えてください特に、Go以外のアプリコンポーネントがたくさんある場合
### `/vendor`
アプリケーションの依存関係 (手動で管理するか、新しい組み込みの [`Go Modules`](https://github.com/golang/go/wiki/Modules) 機能のようなお気に入りの依存関係管理ツールで管理します)。`go mod vendor`コマンドは、`/vendor`ディレクトリを作成します。デフォルトでオンになっている Go 1.14 を使用していない場合は、`go build` コマンドに `-mod=vendor` フラグを追加する必要があるかもしれないことに注意してください。
ライブラリをビルドしている場合は、アプリケーションの依存関係をコミットしないでください。
[`1.13`](https://golang.org/doc/go1.13#modules) 以降、Go はモジュールプロキシ機能も有効にしています (デフォルトでは [`https://proxy.golang.org`](https://proxy.golang.org) をモジュールプロキシサーバとして使用しています)。[`この機能`](https://blog.golang.org/module-mirror-launch)についての詳細は、ここを読んで、あなたの要件や制約に適合するかどうかを確認してください。そうであれば、ベンダディレクトリは全く必要ありません。
## Service Application Directories
### `/api`
OpenAPI/Swaggerの仕様、JSONスキーマファイル、プロトコル定義ファイル。
例に関しては、[`/api`](api/README.md)ディレクトリを参照してください。
## Web Application Directories
### `/web`
ウェブアプリケーション固有のコンポーネント静的ウェブアセット、サーバーサイドテンプレート、SPA。
## Common Application Directories
### `/configs`
設定ファイルのテンプレートまたはデフォルトの設定。
`confd` または `consul-template` テンプレートファイルをここに置きます。
### `/init`
システムinit(systemd, upstart, sysv)とプロセスマネージャ/スーパーバイザ(runit, supervisord)の設定。
### `/scripts`
様々なビルド、インストール、解析などの操作を行うためのスクリプトです。
これらのスクリプトはルートレベルの Makefile を小さくシンプルに保ちます (例: [`https://github.com/hashicorp/terraform/blob/master/Makefile`](https://github.com/hashicorp/terraform/blob/master/Makefile))。
例に関しては、[`/scripts`](scripts/README.md)ディレクトリを参照してください。
### `/build`
パッケージングと継続的インテグレーション。
クラウド (AMI)、コンテナ (Docker)、OS (deb、rpm、pkg) パッケージの設定とスクリプトを `/build/package` ディレクトリに置きます。
CI (travis, circle, drone) の設定とスクリプトを `/build/ci` ディレクトリに配置します。CIツールの中にはTravis CIなど、設定ファイルの場所に非常にこだわるものがあることに注意してください。コンフィグファイルを `/build/ci` ディレクトリに置き、CIツールが期待する場所にリンクしてみてください可能であれば
### `/deployments`
IaaS、PaaS、システム、コンテナオーケストレーションのデプロイメント設定とテンプレート (docker-compose、kubernetes/helm、mesos、terraform、bosh)。
いくつかのリポジトリ (特に kubernetes でデプロイされたアプリ) では、このディレクトリは `/deploy` と呼ばれていることに注意してください。
### `/test`
追加の外部テストアプリとテストデータ。`/test`ディレクトリは自由に構成してください。大規模なプロジェクトでは、データのサブディレクトリを持つことは理にかなっています。例えば、`/test/data` や `/test/testdata` などのディレクトリが必要な場合、そのディレクトリにあるものを無視することができます。Go は "." や "_" で始まるディレクトリやファイルも無視するので、テストデータディレクトリの名前の付け方に柔軟性があることに注意してください。
例に関しては、[`/test`](test/README.md)ディレクトリを参照してください。
## 他のディレクトリ
### `/docs`
デザインドキュメントとユーザードキュメント (godocで生成されたドキュメントに加えて)。
例に関しては、['/docs`](docs/README.md)ディレクトリを参照してください。
### `/tools`
このプロジェクトをサポートするツールです。これらのツールは `/pkg``/internal` ディレクトリからコードをインポートできることに注意してください。
例に関しては、['/tools`](tools/README.md)ディレクトリを参照してください。
### `/examples`
あなたのアプリケーション、またはpublic librariesのための例。
例に関しては、['/examples`](examples/README.md)ディレクトリを参照してください。
### `/third_party`
外部ヘルパーツール、フォークされたコード、その他のサードパーティ製ユーティリティSwagger UIなど
### `/githooks`
Gitフック。
### `/assets`
リポジトリに付随するその他のアセット(画像、ロゴなど)。
### `/website`
Githubページを使用していない場合は、プロジェクトのWebサイトのデータを置く場所です。
例に関しては、['/website`](website/README.md)ディレクトリを参照してください。
## 作成してはいけないディレクトリ
### `/src`
Goプロジェクトの中には `src` フォルダを持っているものもありますが、これは通常、開発者が一般的なパターンであるJavaの世界から来た場合に起こります。可能であれば、このようなJavaのパターンを採用しないようにしてください。あなたのGoコードやGoプロジェクトがJavaのように見えることは本当に避けてください。
プロジェクトレベルの `/src` ディレクトリと、[`Goコードの書き方`](https://golang.org/doc/code.html)で説明されているように、Go がワークスペースに使用する `/src` ディレクトリを混同しないようにしてください。環境変数 `$GOPATH` は、(現在の)ワークスペースを指します (Windows 以外のシステムでは、デフォルトでは `$HOME/go` を指します)。このワークスペースには、トップレベルの `/pkg`, `/bin`, `/src` ディレクトリが含まれています。実際のプロジェクトは `/src` の下のサブディレクトリになりますので、プロジェクト内に `/src` ディレクトリがある場合、プロジェクトのパスは以下のようになります。`/some/path/to/workspace/src/your_project/src/your_code.go` のようになります。Go 1.11 では、プロジェクトを `GOPATH` の外に置くことができますが、このレイアウトパターンを使うのが良いというわけではないことに注意してください。
## Badges
* [Go Report Card](https://goreportcard.com/) - `gofmt`, `go vet`, `gocyclo`, `golint`, `ineffassign`, `license`, `misspell` でコードをスキャンします。`github.com/golang-standards/project-layout` をプロジェクトリファレンスに置き換えてください。
* ~~[GoDoc](http://godoc.org) - GoDocで作成したドキュメントのオンライン版を提供します。リンクを自分のプロジェクトへのリンクに変更してください。
* [Pkg.go.dev](https://pkg.go.dev) - Pkg.go.devは、囲碁の発見とドキュメントの新しい目的地です。[バッジ生成ツール](https://pkg.go.dev/badge)を使ってバッジを作成することができます。
* リリース - あなたのプロジェクトの最新のリリース番号が表示されます。githubのリンクを変更して、あなたのプロジェクトを指すようにしてください。
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-standards/project-layout?style=flat-square)](https://goreportcard.com/report/github.com/golang-standards/project-layout)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/golang-standards/project-layout)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/golang-standards/project-layout)](https://pkg.go.dev/github.com/golang-standards/project-layout)
[![リリース](https://img.shields.io/github/release/golang-standards/project-layout.svg?style=flat-square)](https://github.com/golang-standards/project-layout/releases/latest)
## 注意事項
サンプル/再利用可能なコンフィグ、スクリプト、コードを備えた、より意見の多いプロジェクトテンプレートはWIPです。

@ -6,6 +6,7 @@
* [简体中文](README_zh.md)
* [Français](README_fr.md)
* [正體中文](README_zh-TW.md)
* [日本語](README_ja.md)
## 개요

@ -0,0 +1,180 @@
# Go项目标准布局
🌍 *[English](README.md) ∙ [简体中文](README_zh-CN.md)*
这是Go应用程序项目的基础布局。这不是Go核心开发团队定义的官方标准无论是在经典项目还是在新兴的项目中这都是Go生态系统中一组常见的项目布局模式。这其中有一些模式比另外的一些更受欢迎。它通过几个支撑目录为任何足够大规模的实际应用程序提供一些增强功能。
如果你正准备学习Go、正在构建PoC项目或编写玩具项目那么按照这个项目进行布局就大材小用了。从一些正真简单是的事情开始一个`main.go`文件就足够了)。随着项目的增长,确保代码结构的合理是非常重要的,否则最终会出现很多隐藏的依赖关系和全局状态而到这项目代码混乱。当一个项目多人同时进行时,就更需要有清晰的结构,此时引入一种通用的项目包/标准库管理工具就显得尤为重要。当你维护一个开源项目或者有其他项目导入了你的代码,那么有一个私有的包(如`internal`)就很重要了。克隆这个项目,保留你项目中需要的部分,并删除其他部分。通常来说不需要也没必要使用这个项目中的全部内容。因为,从没有在一个单一的项目中使用本项目中定义的全部模式,甚至如`vendor`模式。
Go 1.14 `Go Modules`已经可以用于生产环境。没有什么特殊原因的话,请使用`Go Modules`,使用它之后,你就在也不用担心`$GOPATH`的配置和项目实际的存放位置,项目想放在哪里就放在哪里。本项目中`go.mod`文件的内容假设你的项目是托管在GitHub上的当然这不是必选项因为`Module`中的路径可以是任意的值,一般`Module`路径的第一部分中应该包含一个点最新版的Go中不再强制要求这一点如果使用的是稍微旧一些的版本那么可能遇到编译失败的问题。了解更多请看Issues [37554](https://github.com/golang/go/issues/37554)和 [32819](https://github.com/golang/go/issues/32819)。
本项目布局有意设计的更通用一些而不会尝试去引入一些特定的Go包结构。
这是社区共同的努力。如果发现了一种新的模式或者项目中已经存在的某些模式需要更新是请新建一个issue。
如果需要一些关于命名、格式化或者样式方面的帮助,请先运行[`gofmt`](https://golang.org/cmd/gofmt/)和[`golint`](https://github.com/golang/lint)。另外请务必阅读以下Go代码样式指南和建议
- https://talks.golang.org/2014/names.slide
- https://golang.org/doc/effective_go.html#names
- https://blog.golang.org/package-names
- https://github.com/golang/go/wiki/CodeReviewComments
- Style guideline for Go packages (rakyll/JBD)
更多背景信息请查看[`Go Project Layout`](https://medium.com/golang-learn/go-project-layout-e5213cdcfaa2)。
有关命名和项目包组织样式以及其他代码结构的更多推荐文章:
- [GopherCon EU 2018: Peter Bourgon - Best Practices for Industrial Programming](https://www.youtube.com/watch?v=PTE4VJIdHPg)
- [GopherCon Russia 2018: Ashley McNamara + Brian Ketelsen - Go best practices](https://www.youtube.com/watch?v=MzTcsI6tn-0)
- [GopherCon 2017: Edward Muller - Go Anti-Patterns](https://www.youtube.com/watch?v=ltqV6pDKZD8)
- [GopherCon 2018: Kat Zien - How Do You Structure Your Go Apps](https://www.youtube.com/watch?v=oL6JBUk6tj0)
## Go目录
### `/cmd`
项目主要的应用程序。
对于每个应用程序来说这个目录的名字应该和项目可执行文件的名字匹配(例如,`/cmd/myapp`)。
不要在这个目录中放太多的代码。如果目录中的代码可以被其他项目导入并使用,那么应该把他们放在`/pkg`目录。如果目录中的代码不可重用,或者不希望被他人使用,应该将代码放在`/internal`目录。显示的表明意图比较好!
通常来说,项目都应该拥有一个小的`main`函数,并在`main`函数中导入或者调用`/internal`和`/pkg`目录中的代码。
更多详情,请看[`/cmd`](https://github.com/golang-standards/project-layout/blob/master/cmd/README.md)目录中的例子。
### `/internal`
私有的应用程序代码库。这些是不希望被其他人导入的代码。请注意这种模式是Go编译器强制执行的。详细内容情况Go 1.4的[release notes](https://golang.org/doc/go1.4#internalpackages)。再次注意,在项目的目录树中的任意位置都可以有`internal`目录,而不仅仅是在顶级目录中。
可以在内部代码包中添加一些额外的结构,来分隔共享和非共享的内部代码。这不是必选项(尤其是在小项目中),但是有一个直观的包用途是很棒的。应用程序实际的代码可以放在`/internal/app`目录(如,`internal/app/myapp`),而应用程序的共享代码放在`/internal/pkg`目录(如,`internal/pkg/myprivlib`)中。
### `/pkg`
外部应用程序可以使用的库代码(如,`/pkg/mypubliclib`)。其他项目将会导入这些库来保证项目可以正常运行,所以在将代码放在这里前,一定要三四而行。请注意,`internal`目录是一个更好的选择来确保项目私有代码不会被其他人导入因为这是Go强制执行的。使用`/pkg`目录来明确表示代码可以被其他人安全的导入仍然是一个好方式。Travis Jeffery撰写的关于 [Ill take pkg over internal](https://travisjeffery.com/b/2019/11/i-ll-take-pkg-over-internal/) 文章很好地概述了`pkg`和`inernal`目录以及何时使用它们。
当您的根目录包含大量非Go组件和目录时这也是一种将Go代码分组到一个位置的方法从而使运行各种Go工具更加容易在如下的文章中都有提到2018年GopherCon [Best Practices for Industrial Programming](https://www.youtube.com/watch?v=PTE4VJIdHPg)[Kat Zien - How Do You Structure Your Go Apps](https://www.youtube.com/watch?v=oL6JBUk6tj0) Golab 2018 [Massimiliano Pippi - Project layout patterns in Go](https://www.youtube.com/watch?v=3gQa1LWwuzk))。
点击查看`/pkg`就能看到那些使用这个布局模式的流行Go代码仓库。这是一种常见的布局模式但未被普遍接受并且Go社区中的某些人不推荐这样做。
如果项目确实很小并且嵌套的层次并不会带来多少价值除非你就是想用它那么就不要使用它。请仔细思考这种情况当项目变得很大并且根目录中包含的内容相当繁杂尤其是有很多非Go的组件
### `/vendor`
应用程序的依赖关系(通过手动或者使用喜欢的依赖管理工具,如新增的内置[Go Modules](https://github.com/golang/go/wiki/Modules)特性)。执行`go mod vendor`命令将会在项目中创建`/vendor`目录注意如果使用的不是Go 1.14版本,在执行`go build`进行编译时,需要添加`-mod=vendor`命令行选项,因为它不是默认选项。
构建库文件时,不要提交应用程序依赖项。
请注意,从[1.13](https://golang.org/doc/go1.13#modules)开始Go也启动了模块代理特性使用`https//proxy.golang.org`作为默认的模块代理服务器)。点击[这里](https://blog.golang.org/module-mirror-launch)阅读有关它的更多信息,来了解它是否符合所需要求和约束。如果`Go Module`满足需要,那么就不需要`vendor`目录。
## 服务端应用程序的目录
### `/api`
OpenAPI/Swagger规范JSON模式文件协议定义文件。
更多样例查看[`/api`](https://github.com/golang-standards/project-layout/blob/master/api/README.md)目录。
## Web应用程序的目录
### `/web`
Web应用程序特定的组件静态Web资源服务器端模板和单页应用Single-Page AppSPA
## 通用应用程序的目录
### `/configs`
配置文件模板或默认配置。
将`confd`或者`consul-template`文件放在这里。
### `/init`
系统初始化systemd、upstart、sysv和进程管理runit、supervisord配置。
### `/scripts`
用于执行各种构建,安装,分析等操作的脚本。
这些脚本使根级别的Makefile变得更小更简单例如 https://github.com/hashicorp/terraform/blob/master/Makefile
更多样例查看[`/scripts`](https://github.com/golang-standards/project-layout/blob/master/scripts/README.md)。
### `/build`
打包和持续集成。
将云AMI容器Docker操作系统debrpmpkg软件包配置和脚本放在`/build/package`目录中。
将CItravis、circle、drone配置文件和就脚本放在`build/ci`目录中。请注意有一些CI工具travis CI对于配置文件的位置有严格的要求。尝试将配置文件放在`/build/ci`目录然后链接到CI工具想要的位置。
### `/deployments`
IaaSPaaS系统和容器编排部署配置和模板docker-composekubernetes/helmmesosterraformbosh。请注意在某些存储库中尤其是使用kubernetes部署的应用程序该目录的名字是`/deploy`。
### `/test`
外部测试应用程序和测试数据。随时根据需要构建`/test`目录。对于较大的项目有一个数据子目录更好一些。例如如果需要Go忽略目录中的内容则可以使用`/test/data`或`/test/testdata`这样的目录名字。请注意Go还将忽略以“`.`”或“`_`”开头的目录或文件,因此可以更具灵活性的来命名测试数据目录。
更多样例查看[`/test`](https://github.com/golang-standards/project-layout/blob/master/test/README.md)。
## 其他
### `/docs`
设计和用户文档除了godoc生成的文档
更多样例查看[`/docs`](https://github.com/golang-standards/project-layout/blob/master/docs/README.md)。
### `/tools`
此项目的支持工具。请注意,这些工具可以从`/pkg`和`/internal`目录导入代码。
更多样例查看[`/tools`](https://github.com/golang-standards/project-layout/blob/master/tools/README.md)。
### `/ examples`
应用程序或公共库的示例。
更多样例查看[`/examples`](https://github.com/golang-standards/project-layout/blob/master/examples/README.md)。
### `/third_party`
外部辅助工具fork的代码和其他第三方工具例如Swagger UI
### `/githooks`
Git的钩子。
### `/assets`
项目中使用的其他资源图像Logo等
### `/website`
如果不使用Github pages则在这里放置项目的网站数据。
更多样例查看[`/website`](https://github.com/golang-standards/project-layout/blob/master/website/README.md)。
## 不应该出现的目录
### `/src`
有一些Go项目确实包含`src`文件夹但通常只有在开发者是从Java这是Java中一个通用的模式转过来的情况下才会有。如果可以的话请不要使用这种Java模式。你肯定不希望你的Go代码和项目看起来向Java。
不要将项目级别的`/src`目录与Go用于其工作空间的`/src`目录混淆,就像[How to Write Go Code](https://golang.org/doc/code.html)中描述的那样。`$GOPATH`环境变量指向当前的工作空间默认情况下指向非Windows系统中的`$HOME/go`)。此工作空间包括顶级`/pkg``/bin`和`/src`目录。实际的项目最终变成`/src`下的子目录,因此,如果项目中有`/src`目录,则项目路径将会变成:`/some/path/to/workspace/src/your_project/ src/your_code.go`。请注意使用Go 1.11可以将项目放在GOPATH之外但这并不意味着使用此布局模式是个好主意。
## 徽章
- [Go Report Card](https://goreportcard.com/):它将使用`gofmt``vet``gocyclo``golint``ineffassign``license`和`mispell`扫描项目中的代码。将`github.com/golang-standards/project-layout`替换为你的项目的引用。
- [GoDoc](http://godoc.org/)它将提供GoDoc生成的文档的在线版本。更改链接以指向你的项目。
- Release它将显示你项目的最新版本号。更改github链接以指向你的项目。
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-standards/project-layout?style=flat-square)](https://goreportcard.com/report/github.com/golang-standards/project-layout)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/golang-standards/project-layout)
[![Release](https://img.shields.io/github/release/golang-standards/project-layout.svg?style=flat-square)](https://github.com/golang-standards/project-layout/releases/latest)
## 注意
WIP项目是一个自以为是的项目模板其中带有`sample/reusable`配置、脚本和代码。

@ -6,8 +6,9 @@
* [简体中文](README_zh.md)
* [Français](README_fr.md)
* [正體中文](README_zh-TW.md)
* [日本語](README_ja.md)
这是 Go 应用程序项目的基本布局。它不是核心 Go 开发团队定义的官方标准;然而,它是 Go 生态系统中一组常见的老项目和新项目的局模式。其中一些模式比其他模式更受欢迎。它还具有许多小的增强,以及对任何足够大的实际应用程序通用的几个支持目录。
这是 Go 应用程序项目的基本布局。它不是核心 Go 开发团队定义的官方标准;然而,它是 Go 生态系统中一组常见的老项目和新项目的局模式。其中一些模式比其他模式更受欢迎。它还具有许多小的增强,以及对任何足够大的实际应用程序通用的几个支持目录。
如果你尝试学习 Go或者你正在为自己建立一个 PoC 或一个玩具项目,这个项目布局是没啥必要的。从一些非常简单的事情开始(一个 `main.go` 文件绰绰有余)。随着项目的增长,请记住保持代码结构良好非常重要,否则你最终会得到一个凌乱的代码,这其中就包含大量隐藏的依赖项和全局状态。当有更多的人参与这个项目时,你将需要更多的结构。这时候,介绍一种管理包/库的通用方法是很重要的。当你有一个开源项目时,或者当你知道其他项目从你的项目存储库中导入代码时,这时候拥有私有(又名 `internal`)包和代码就很重要。克隆存储库,保留你需要的内容,删除其他所有的内容!仅仅因为它在那里并不意味着你必须全部使用它。这些模式都没有在每个项目中使用。甚至 `vendor` 模式也不是通用的。

@ -39,7 +39,6 @@ Examples:
* https://github.com/knative/serving/tree/master/pkg
* https://github.com/grafana/loki/tree/master/pkg
* https://github.com/bloomberg/goldpinger/tree/master/pkg
* https://github.com/crossplaneio/crossplane/tree/master/pkg
* https://github.com/Ne0nd0g/merlin/tree/master/pkg
* https://github.com/jenkins-x/jx/tree/master/pkg
* https://github.com/DataDog/datadog-agent/tree/master/pkg

Loading…
Cancel
Save