¿Qué es Buffalo?

¿Qué es la herramienta GoBuffalo framework?

Un ecosistema para el desarrollo web en Go. Diseñado para facilitar tu vida.

En General

Introducción

Si bien Buffalo puede considerarse como un marco, es principalmente un ecosistema de bibliotecas Go y Javascript seleccionadas para encajar juntas. La mayoría de estos componentes se pueden cambiar por otros, pero solo brindaremos soporte para esta combinación predeterminada.

Ahora, haremos un recorrido por los componentes predeterminados que tienes disponibles con tu aplicación Buffalo.

Bibliotecas de back-end

Buffalo :

Buffalo es el “pegamento” entre todos los componentes proporcionados. Envuelve las bibliotecas y administra el flujo de trabajo.

gorilla/mux :

gorilla/mux es uno de los enrutadores más utilizados en Go. Si bien algunos enrutadores son más rápidos (como httprouter), gorilla/mux es el que brinda la mayor cantidad de funciones y es lo suficientemente rápido.

Pop :

pop es el ORM predeterminado para Buffalo. Proporciona la caja de herramientas soda para ayudarte con tus necesidades de base de datos y es compatible con varias bases de datos, como PostgreSQL, MySQL y SQLite.

Plush :

plush es el motor de plantillas predeterminado de Buffalo. Su sintaxis es cercana a las plantillas ERB (en Ruby).

Bibliotecas de front-end

bootstrap :

bootstrap es una de las bibliotecas de herramientas frontend más famosas. Ayuda a crear interfaces responsivas utilizando componentes comunes como tablas, carruseles o diseños de cuadrícula.

jQuery :

jQuery es una rica biblioteca que tiene como objetivo simplificar la manipulación DOM y las consultas AJAX. Si bien ahora se usa menos, muchos proyectos todavía lo tienen como complemento para ayudar a admitir todos los navegadores.

webpack :

webpack es un conocido paquete de activos de Javascript. Se encargará de sus archivos Javascript, CSS, imágenes y activos estáticos.

webpack está configurado de forma predeterminada para aplicar hash y minificar sus activos.

Características Principales

Background Workers

Si está familiarizado con las tareas Rake de Ruby, se sentirá como en casa usando Grift. ¡Generar datos para una base de datos, ejecutar un trabajo de limpieza ahora es más fácil!

Buffalo Toolkit

Escribir un módulo de aplicación web siempre comienza con las mismas tareas. Buffalo le proporciona una caja de herramientas simple, el comando buffalo, para generar muchas partes de su aplicación y ejecutar tareas habituales.

Frontend Pipeline

Utilice la configuración generada por Webpack para crear los activos de interfaz de su aplicación. Buffalo le permite desarrollar ambas capas (Frontend y Backend) desde el primer momento.

Hot Code Reload

Code, save, refresh. Use the buffalo dev command to rebuild your app, from backend to frontend, and just see the changes live!

ORM

La integración profunda con Pop proporciona una forma sencilla de manejar la base de datos y las tareas relacionadas comunes. Pop es compatible con MySQL/MariaDB, PostgreSQL, CockroachDB y SQLite.

Routing

Buffalo utiliza el kit de herramientas Gorilla para gestionar rutas, sesiones, cookies… Puede haber enrutadores más rápidos, ¡pero este es definitivamente el más poderoso!

Templating

Escriba sus plantillas con Plush, utilizando una sintaxis similar a la de ERB. Amplíe sus funciones utilizando helpers personalizados. Si no le gusta, puedes usar html/template o incluso traer el tuyo propio.

Testing

Dado que las pruebas pueden ser una tarea aburrida, Buffalo lo ayuda a definir conjuntos de pruebas. Los generadores de acciones, recursos y modelos crean plantillas de prueba para el código que acaba de generar.

¿Te gustaría comenzar a usar  Buffalo?

Como Empezar; Empecemos por instalar Buffalo.

Como Instalar Buffalo:

Buffalo proporciona dos componentes principales:

La herramienta buffalo, y el framework buffalo:

Uno es una herramienta potente para ayudarle a desarrollar en una manera rápida y eficiente y el otro es una colección de piezas para construir su aplicación.

Requisitos de frontend

Node version 8 o superior y ya sea Yarn o npm para la Asset Pipeline construido sobre Webpack.

Requisitos de backend

SQLite 3: GCC, o un compilador de c equivalente para mattn/go-sqlite3.

GNU / Linux

MacOS

$ curl -OL https://github.com/gobuffalo/cli/releases/download/v0.18./buffalo_0.18.8_Darwin_x86_64.tar.gz

$ tar -xvzf buffalo_0.18.8_Darwin_x86_64.tar.gz

$ sudo mv buffalo /usr/local/bin/buffalo

# or if you have ~/bin folder setup in the environment PATH variable

$ mv buffalo ~/bin/buffalo

Scoop (Windows)

PS C:\> scoop install buffalo

Verifica tu instalación

Tu puedes comprobar si tu instalacion esta funcionando ejecutando buffalo en la terminal:

$ buffalo

Build Buffalo applications with ease

Usage: buffalo [command]

Available Commands:

build Build the application binary, including bundling of webpack assets

completion Generate the autocompletion script for the specified shell

db [PLUGIN] [DEPRECATED] please use `buffalo pop` instead.

destroy Destroy generated components

dev Run the Buffalo app in ‘development’ mode

fix Attempt to fix a Buffalo applications API to match version v0.18.6

generate Generate application components

help Help about any command

info Print diagnostic information (useful for debugging)

new Creates a new Buffalo application

plugins tools for working with buffalo plugins

pop [PLUGIN] A tasty treat for all your database needs

routes Print all defined routes

setup Setup a newly created, or recently checked out application.

task Run grift tasks

test Run the tests for the Buffalo app. Use –force-migrations to skip schema load.

version Print the version information

Flags: -h, –help help for buffalo

Use «buffalo [command] –help» for more information about a command.

Bueno si todo funciona

El siguiente paso

Seria crear tu primer proyecto

Generando un Nuevo Proyecto

Ahora que ya tienes instalado el framework Buffalo, en esta sección, tu vas a aprender como crear Una nueva Aplicación web usando el comando buffalo.

El objetivo de Buffalo es que la construcción de una aplicación web en Go sea lo mas rapido y sencilla posible. Que podria ser mas sencillo que un generador de un nueva aplicación?

Comienza por ir a tu carpeta favorita donde quieras crear tu proyecto, luego:

$ buffalo new coke

Esto generará aplicacion de Buffalo llamada Coke, lista para funcionar:

• El Diseño del framework de Buffalo y su configuración por defecto (pop/soda con soporte a PostgreSQL).
• Toda las Dependencias de Go necesarias para correr la aplicación.
• Dependencias del lado Frontend y la configuración con webpack.
• Y un Repositorio de Git inicial.

$ buffalo new coke
DEBU[2022-05-25T11:06:33-05:00] Step: 435aea40
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] Exec: go mod init coke
go: creating new go.mod: module coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/README.md
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/actions_test.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/app.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/home.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/home_test.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/render.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/cmd/app/main.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.codeclimate.yml
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.env
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/fixtures/sample.toml
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/grifts/init.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/inflections.json
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/config/buffalo-app.toml
DEBU[2022-05-25T11:06:33-05:00] Step: 638bde0d
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/Dockerfile
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.dockerignore
DEBU[2022-05-25T11:06:33-05:00] Step: 7065092d
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/grifts/db.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/models/models.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/models/models_test.go
DEBU[2022-05-25T11:06:33-05:00] Step: 916dfca0
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/database.yml
DEBU[2022-05-25T11:06:33-05:00] Step: ff1c6d38
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.buffalo.dev.yml
DEBU[2022-05-25T11:06:33-05:00] Step: 103396c6
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] Exec: go install github.com/gobuffalo/buffalo-pop/v3@latest
DEBU[2022-05-25T11:06:34-05:00] Step: ae1260b1
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/config/buffalo-plugins.toml
DEBU[2022-05-25T11:06:34-05:00] Step: 4992ff46
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/app.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/home.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/home_test.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/render.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/locales/all.en-us.yaml
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/locales/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/robots.txt
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/_flash.plush.html
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/application.plush.html
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/home/index.plush.html
DEBU[2022-05-25T11:06:34-05:00] Step: 69d71878
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] LookPath: yarn
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/css/_buffalo.scss
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/css/application.scss
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/images/favicon.ico
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/images/logo.svg
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/js/application.js
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/.babelrc
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/package.json
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/postcss.config.js
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/assets/keep
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/webpack.config.js
DEBU[2022-05-25T11:06:34-05:00] LookPath: yarn
DEBU[2022-05-25T11:06:34-05:00] Exec: yarn --version
1.22.17
DEBU[2022-05-25T11:06:34-05:00] Exec: yarn set version berry
➤ YN0000: Retrieving https://repo.yarnpkg.com/3.2.1/packages/yarnpkg-cli/bin/yarn.js
➤ YN0000: Saving the new release in .yarn/releases/yarn-3.2.1.cjs
➤ YN0000: Done in 0s 637ms
DEBU[2022-05-25T11:06:37-05:00] Exec: yarn config set enableGlobalCache true
➤ YN0000: Successfully set enableGlobalCache to true
DEBU[2022-05-25T11:06:37-05:00] Exec: yarn config set logFilters --json [{"code":"YN0013","level":"discard"}]
➤ YN0000: Successfully set logFilters to [
  {
    code: 'YN0013',
    text: undefined,
    pattern: undefined,
    level: 'discard'
  }
]
DEBU[2022-05-25T11:06:37-05:00] Exec: yarn --version
3.2.1
DEBU[2022-05-25T11:06:38-05:00] Exec: yarn install
DEBU[2022-05-25T11:06:38-05:00] ➤ YN0000: ┌ Resolution step

DEBU[2022-05-25T11:06:39-05:00] ➤ YN0032: │ fsevents@npm:2.3.2: Implicit dependencies on node-gyp are discouraged

DEBU[2022-05-25T11:06:43-05:00] ➤ YN0000: └ Completed in 5s 401ms

DEBU[2022-05-25T11:06:43-05:00] ➤ YN0000: ┌ Fetch step

DEBU[2022-05-25T11:06:43-05:00] ➤ YN0000: └ Completed

DEBU[2022-05-25T11:06:43-05:00] ➤ YN0000: ┌ Link step

DEBU[2022-05-25T11:06:44-05:00] ➤ YN0000: │ ESM support for PnP uses the experimental loader API and is therefore experimental

DEBU[2022-05-25T11:06:44-05:00] ➤ YN0007: │ @fortawesome/fontawesome-free@npm:5.15.4 must be built because it never has been before or the last one failed

DEBU[2022-05-25T11:06:44-05:00] ➤ YN0000: └ Completed in 0s 906ms

DEBU[2022-05-25T11:06:44-05:00] ➤ YN0000: Done with warnings in 6s 462ms

DEBU[2022-05-25T11:06:44-05:00] Step: bb3c28ed
DEBU[2022-05-25T11:06:44-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:44-05:00] Exec: go mod tidy
go: finding module for package github.com/gobuffalo/buffalo
go: finding module for package github.com/gobuffalo/mw-paramlogger
go: finding module for package github.com/gobuffalo/buffalo-pop/v3/pop/popmw
go: finding module for package github.com/gobuffalo/mw-i18n/v2
go: finding module for package github.com/gobuffalo/buffalo/render
go: finding module for package github.com/gobuffalo/mw-forcessl
go: finding module for package github.com/gobuffalo/envy
go: finding module for package github.com/gobuffalo/mw-csrf
go: finding module for package github.com/unrolled/secure
go: finding module for package github.com/markbates/grift/grift
go: finding module for package github.com/gobuffalo/pop/v6
go: finding module for package github.com/gobuffalo/suite/v4
go: found github.com/gobuffalo/buffalo in github.com/gobuffalo/buffalo v0.18.7
go: found github.com/gobuffalo/buffalo-pop/v3/pop/popmw in github.com/gobuffalo/buffalo-pop/v3 v3.0.4
go: found github.com/gobuffalo/buffalo/render in github.com/gobuffalo/buffalo v0.18.7
go: found github.com/gobuffalo/envy in github.com/gobuffalo/envy v1.10.1
go: found github.com/gobuffalo/mw-csrf in github.com/gobuffalo/mw-csrf v1.0.0
go: found github.com/gobuffalo/mw-forcessl in github.com/gobuffalo/mw-forcessl v0.0.0-20220514125302-be60179938a4
go: found github.com/gobuffalo/mw-i18n/v2 in github.com/gobuffalo/mw-i18n/v2 v2.0.1
go: found github.com/gobuffalo/mw-paramlogger in github.com/gobuffalo/mw-paramlogger v1.0.0
go: found github.com/unrolled/secure in github.com/unrolled/secure v1.10.0
go: found github.com/markbates/grift/grift in github.com/markbates/grift v1.5.0
go: found github.com/gobuffalo/pop/v6 in github.com/gobuffalo/pop/v6 v6.0.4
go: found github.com/gobuffalo/suite/v4 in github.com/gobuffalo/suite/v4 v4.0.2
DEBU[2022-05-25T11:06:45-05:00] Exec: go mod download
DEBU[2022-05-25T11:06:46-05:00] Step: 218a906c
DEBU[2022-05-25T11:06:46-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:46-05:00] Step: a3cee09e
DEBU[2022-05-25T11:06:46-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:46-05:00] File: /your/path/coke/.gitignore
DEBU[2022-05-25T11:06:46-05:00] Exec: git init
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: 	git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: 	git branch -m <name>
Initialized empty Git repository in /your/path/coke/.git/
DEBU[2022-05-25T11:06:46-05:00] Exec: git add .
DEBU[2022-05-25T11:06:46-05:00] Exec: git commit -q -m Initial Commit
INFO[2022-05-25T11:06:46-05:00] Congratulations! Your application, coke, has been successfully generated!
INFO[2022-05-25T11:06:46-05:00] You can find your new application at: /your/path/coke
INFO[2022-05-25T11:06:46-05:00] Please read the README.md file in your new application for next steps on running your application.

Crear una App Personalizada#

La configuración por defecto esta perfecta, pero tal vez eso no se adapte a ti. Buffalo provee algunas opciones como banderas para el comando new

Tu puede obtener las banderas disponibles usando el comando help

$ buffalo help new
Creates a new Buffalo application

Usage:
  buffalo new [name] [flags]

Flags:
      --api                  skip all front-end code and configure for an API server
      --ci-provider string   specify the type of ci file you would like buffalo to generate [none, travis, gitlab-ci, circleci] (default "none")
      --config string        config file (default is $HOME/.buffalo.yaml)
      --db-type string       specify the type of database you want to use [cockroach, mariadb, mysql, postgres, sqlite3] (default "postgres")
  -d, --dry-run              dry run
  -f, --force                delete and remake if the app already exists
  -h, --help                 help for new
      --module string        specify the root module (package) name. [defaults to 'automatic']
      --skip-config          skips using the config file
      --skip-docker          skips generating the Dockerfile
      --skip-pop             skips adding pop/soda to your app
      --skip-webpack         skips adding Webpack to your app
      --skip-yarn            use npm instead of yarn for frontend dependencies management
      --vcs string           specify the Version control system you would like to use [none, git, bzr] (default "git")
  -v, --verbose              verbosely print out the go get commands

Tu puede elegir generar una aplicacion API, saltando el material frontend. ¿Tal vez tu quieres configurar un CI para construir tu aplicación en tu sistema favorito? ¿O incluso usar tu propio paquete para manejar la base de datos? ¡Solo usa la bandera!

Sobreescribir Configuración por Defecto#

Por defecto el comando buffalo new va a mirar el archivo de configuración $HOME/.buffalo.yml y si existe tratará de cargarlo. Tu puedes sobreescribir las banderas encontrandolas en ese archivo pasando lo correcto en la linea de comandos o utilizar la bandera --config para especificar un archivo YAML diferente. Si la bandera --skip-config es usado. El comando buffalo new no va a cargar ningun archivo de configuración y solo va a usar las banderas pasadas por la linea de comandos.

Un ejemplo de .buffalo.yml puede ser:

skip-yarn: true
db-type: postgres
bootstrap: 4
with-dep: true

Corriendo Tu Aplicacion en Desarrollo#
Antes de comenzar con buffalo por primera vez, por favor dirijase a documentacion de Base de datos y lea un poco sobre la configuración de tus bases de datos.

Una de las desventajas de usar Go en desarrollo es la falta de “recarga” de código. Esto quiere decir que a medida que cambias tu código tu necesitas parar manualmente tu aplicacion, reconstruirla y luego reiniciarla. Buffalo encuentra esto muy molesto y quiere hacer la vida mas facil para ti.

$ buffalo dev

El comando dev va a mirar tus archivos .go and .html y la carpeta asset por defecto. Eso va a reconstruir y reestablecer tu binario para ti automaticamente, asi que no te preocupes por esas cosas.

Solo corre el comando buffalo dev y ve a localhost:3000/ para todos los cambios.
Corre el servidor de desarrollo en un puerto personalizado#

Algunas veces tu vas a tener una aplicación en un puerto 3000. Tu puedes configurar el puesto del servidor de desarrollo proporcionando la variable de entorno PORT.

$ PORT=3001 buffalo dev 

Tu puedes tambien mirar el capitulo de Env Variables para mas information de la configuración de Buffalo.

Siguiente Paso#

Estructura de Directorio

Buffalo te proporciona a ti una estructura de directorio minimo para trabajar en tu proyecto. Esta estructura mantiene el proyecto limpio, y permite el generador trabajar. No trates de reinventar la rueda, y deja que buffalo te compre mas tiempo para hacer la parte interesante de tu app! 🙂

Ahora que tu tienes un proyecto minimo, vamos a su contenido:

Directorio Raiz#

Aqui esta la estructura de un Proyecto Buffalo:

├── .yarn/
├── actions/
│	├── app.go
│	└── render.go
├── assets/
├── cmd/
│	└── app/
│		└── main.go
├── config/
├── fixtures/
├── grifts/
├── locales/
├── models/
├── public/
├── templates/
├── .babelrc
├── .buffalo.dev.yml
├── .codeclimate.yml
├── .docketignore
├── .env
├── .gitignore
├── .pnp.loader.mjs
├── .yarnrc.yml
├── database.yml
├── Dockerfile
├── go.mod
├── go.sum
├── inflections.json
├── package.json
├── postcss.config.js
├── README.md
├── webpack.config.js
└── yarn.lock

Actions#

Este directorio maneja la parte de Controlador del patron MVC. Eso contiene los controladores para tus URLs, un plus:

• El app.go es el archivo para configurar tu app y rutas.
• El render.go es el archivo para configurar el motor de las plantillas.

Assets#

Este directorio es opcional. Si tu no necesitas usar una configuración para el frontend (Solo API, por ejemplo), puedes quitarlo sin problemas.

Este directorio contiene raw assets el cual sera compilado/comprimido y puestos en el directorio public.

Cmd#

Esta carpeta contiene el main.go es el archivo el cual arranca tu app y la inicia.

Grifts#

Este directorio es opcional. Si tu no necesitas usarlo tasks, puedes quitarlo sin problemas.

Este directorio contiene el tasks impulsado por grift.

Locales#

Este directorio es opcional. Si tu usas un solo lenguaje, tu puedes remover esto y el modulo i18n desde el archivo app.go en el directorio actions

Este directorio is usado por el sistema de i18n. Eso va a traer la traduccion de cadenas desde aqui.

Models#

Si tu usas pop/soda con el generador integrado, eso generará los archivos del modelo aqui.

Este directorio es opcional. Si tu no necesitas usar una base de datos, puedes removerlo.

Este directorio se encarga de la parte del Model de el patrón MVC. Eso contiene el archivo models.go para inicializar la conexion con la fuente de datos y el modelo para reflejar objetos de la base de datos.

Public#

El contenido de este directorio se genera automaticamente.

Este directorio contiene asset publico (Compilado/Comprimido). Si tu usas webpack, los assets se van a colocar en este directorio.

Templates#

Este directorio es opcional. Si tu no necesitas usar una configuración de frontend (Solo API, por ejemplo), puedes quitarlo sin problemas.

Este directorio maneja la Vista de el patron MVC. Eso contiene los templates de el proyecto, usado para renderizar las vistas.

Tmp#

El contenido de este directorio es autogenerado.

Este directorio es usado por el comando buffalo dev para reconstruir tu proyecto con cada cambio. Los archivos temporales de Buffalo se van a colocar aqui.

Database.yml#

Este archivo es opcional. Si tu no necesitas una base de datos, o si tu quieres manejar la base de datos sin pop/soda puedes removerlo.

Este archivo contiene la configuración de la base de datos para pop/soda.

Siguiente Paso#

Configuración#

En este capitulo, tu vas a aprender como manejar la configuración de tu proyecto con Buffalo.

Las variables de entorno son un buen camino para separar entornos con diferentes valores o secretos, de la base del código de tu aplicación. (como describe en la aplicación de los Doce factores). Eso puede ayudar a definir el comportamiento quese basa en el contexto de la aplicación (Como requerir SSL en producción) y aislas secretos de tu código. De esta manera, todos los desarroladores no tienen que conocer las llaves de producción para servicios sensibles como la API de un Banco y pueden utilizar las llaves de la API en sandbox.

Variables de entorno Permitidas#

Las siguientes variables son usadas por Buffalo:

Configuración Personalizada#

Tu puedes proporcionar tus propias variables y recuperarlas desde su aplicación. El paquete envy hace esto facil!

import "github.com/gobuffalo/envy"

// [...]

// Get MYSECRET env variable, default to empty string if it's not set
var MYSECRET = envy.Get("MYSECRET", "")

// Get REQUIREDSECRET env variable, return an error if it's not set
REQUIREDSECRET, err := envy.MustGet("REQUIREDSECRET")

Soporte para archivos .env#

Buffalo entrega soporte con .env (desde buffalo >= 0.10.3), lo que significa que buffalo cargará los archivos .env dentro de la variable del entorno una vez que la aplicacion esté corriendo. Para hacer eso Buffalo usa envy.Load el cual buscará el archivo .env en la raiz de tu aplicación.

Si tu no estas familiarizado como luce un archivo .env, aqui tienes un ejemplo:

SENDGRID_API_KEY=ABCCOQ7GFRVCW0ODHPFQ3FTP5SLL1Q
SENDGRID_EMAIL=email@myapp.com

APP_DEBUG=true
APP_LOG_LEVEL=debug
APP_URL=https://myapp.com

Las aplicaciones generadas (con buffalo >= 0.10.3) van a crear un archivo .env por defecto en la raiz de su aplicación. Este archivo va será mirado por Buffalo para los cambios pero va a ser ignorado por git (Añadido en el .gitignore). Esto es una buena manera de evitar que los desarrolladores suban las credenciales por error.

Siguiente Paso#

Integración de Herramientas#

Tu puedes trabajar con Buffalo usando tu herramienta preferida. Aqui tienes una lista de herramientas para terminales, IDES, y otras herramientas.

Auto Completado zsh#

Si tu usas la terminal con zsh, puedes usar este plugin creado por @1995parham: https://github.com/1995parham/buffalo.zsh

Auto Completado bash#

Si tu usas la terminal con bash, puedes tratar de usar este script, creado por @cippaciong, el cual provee el auto completado basico: https://github.com/cippaciong/buffalo_bash_completion

Extension de Go para Visual Studio Code#

Si tu usas Visual Studio Code como tu editor de Código, puedes usar esta extension: Go.

Si no puedes esperar a que termine de escribir esta guía, puedes visitar mientras tanto la página original.

¿Te has quedado con alguna duda o pregunta? Entonces te pido que dejes un comentario. Da igual que sea o una duda o un simple gracias, pero me alegraré mucho de leerlo y responderlo.

¡Cuéntame en los comentarios!

Enlaces internos:

Últimas Noticias Digitales

Blog

Tienda

Sí, te ha Gustado.

¡Cuéntame en los comentarios!