You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
3 Hrs
19 Min
24 Seg

Los secretos de Rails

10/36
Resources

How does Rails handle sensitive information?

In the vast world of Ruby on Rails, one of the most crucial aspects is the management of sensitive information, such as login credentials. This becomes even more important as your application grows and more developers join the project. Rails has developed a number of methods to securely manage this sensitive data.

What happens when you release your application to production?

When you decide to release your application, credential management becomes a priority. Imagine sharing the same credentials from your local environment with the production environment. This approach, in addition to being insecure, lacks confidentiality and becomes a potential organizational headache.

Rails proposes an effective solution by using configuration files such as database.yaml and credentials.yaml.enc. These help keep credentials safe and secure, separating what is needed between different environments.

What is the evolution of secrets handling in Rails?

  1. Beginnings with database.yaml: In the first versions, the database.yaml file was the main tool for database configuration.

  2. Introduction of secrets.yaml: In Rails 4, this file was added to manage credentials in a more structured way, although still with areas of improvement.

  3. Progress with encrypted credentials: Starting with version 5.2, the inclusion of encrypted credentials represented a significant leap. This allowed the confidentiality of information to be maintained while sharing secure structures.

  4. Maturity in Rails 6: Here, credential handling reached a new level of sophistication, aligning with the principles of the 12-Factor App manifesto to follow software architecture best practices.

How to interact with the Rails credential system?

Interacting with the Rails credential system is mainly done through the console and the text editor. Here's how:

  1. Access the credentials.yaml.enc file:

    • Navigate to your project's config folder and locate the credentials.yaml.enc file.
    • This file is encrypted and will require an editor to modify it.
  2. Using the console:

    • Open a new console and run the rails credentials:edit command to edit the credentials file.
    • Configure your editor of choice, e.g. nano, to access the encrypted content.
  3. Enter new keys:

    • You can add new keys, for example, hello: 123456, which creates a key-value pair in the credentials.
  4. Saving and encryption:

    • Save the changes and verify that the file has been encrypted correctly.

How to use credentials in your application?

To make practical use of these credentials within your application, follow these steps:

  1. Access the credentials from Rails:

    • In the Rails console, access the encrypted content using:
      Rails.application.credentials.hello.
    • This will allow you to get the value associated with the hello key.
  2. Implement in controllers:

    • In the controller, for example, WelcomeController, you can define an instance variable with the credentials:
      @credentials = Rails.application.credentials.hello
  3. Show in views:

    • Modify the corresponding view so that this variable is printed. Duplicate the line and display the credential value.

Although this exercise is purely practical and credentials are generally not directly displayed, this knowledge is essential to master how Rails handles sensitive data security.

With this knowledge, you are better prepared to securely handle sensitive information in your Rails applications. Keep practicing and expanding your skills in the world of web development!

Contributions 13

Questions 4

Sort by:

Want to see more contributions, questions and answers from the community?

en Windows para entrar al a editar el archivo
set EDITOR=notepad
rails credentials:edit

Aquí les va mi aporte:

En el controller welcome_controller.rb

def hello
    @variable = Pet.first.name
    @variable_dos = Pet.first.breed
  end

En el hello.html.erb:

<p>Hola me llamo <%= @variable %> y soy un <%= @variable_dos %></p>

Mi Aporte:

Variables
Declaración de variables, sus alcances y convenciones

Variables globales, fuera de la clase
Las variables globales o fuera de clase se declaran anteponiendo un signo peso ($), ejemplo:
irb(main):001> $variable = 1+1

Variables de instancia
Las variables de instancia se declaran anteponiendo un signo arroba (@), ejemplo:
irb(main):001> @variable = 1+1

Variables locales
Las variables locales se declaran sin anteponer algún signo o símbolo, ejemplo:
irb(main):001> variable = 1+1

Convenciones para declarar variables
Generalmente para declarar variables se utiliza la convención underscore, que permite hacer más legible la lectura de las variables, ejemplo.
irb(main):001> variable_flotante = 1.2
irb(main):001> variable_entera = 12345
irb(main):001> variable_cadena = “qwerty”

Si cuando ejecutas el metodo **Rails.application.credentials.hello** te sale **nil,** vuelve a ejecutar el comando Rails console****

Para los que estén viendo este tutorial y tengan ruby 7
con la terminal powershell de windows se usa este comando para editar las credenciales

$env:EDITOR="code --wait"
rails credentials:edit

Como trata Rails los datos sensibles

Una base de datos viene por defecto en las aplicaciones RoR llamada SQLite. SQLite tiene integrado, por defecto, un sistema de credenciales de acceso.
Manejo de secretos con Rails
++
Rails ha diseñado estrategias para lidiar con datos confidenciales. Desde sus primeras versiones hasta la actualidad se ha usado el archivo database.yml. En este archivo esta la configuración de acceso para las bases de datos.
++
No fue hasta la versión 5.2 en que se integraron credenciales encriptadas. Gracias a esta actualización se obtuvo la posibilidad de compartir estructuras mientras se conservaba la confidencialidad.
++
En el archivo database.yml se centra todo le sistema de información sensible.
++
El archivo credentials.yml.enc es un archivo con contenido encriptado. No es posible editarlo ya que necesita del cmd. En el cmd escribimos

EDITOR=nano rails credentials:edit

Este comando nos llevará a un editor en consola donde podremos editar el contenido. Una vez ahi podemos ver una clave por default. Podemos crear la nuestra usando una palabra:numero (hello:123456). Usamos ctrl + x -> y - > enter. Podemos acceder a este archivo usando la clase
Rails. Podemos acceder a las claves creadas usando .nombre_clave

Rails.application.credentials

Si vamos al controlador, creado previamente en el editor de texto (welcome_controller.rb), podemos crear una variable dentro de la acción que tenemos (hello), a esta variable le asignamos la invocación anterior (Rails.application.credentials)

Si les pasa que no se les muestra en la vista el valor de: Rails.application.credentials.hello solo deben detener y volver a lanzar el servidor de rails.

Como trata Rails los datos sensibles

Rails ya viene con una base de datos viene por defecto llamada SQLite. SQLite tiene integrado por defecto, un sistema de credenciales de acceso; por lo que no es necesario preocuparse por hacer pruebas con ella.

Sin embargo, en un entorno de desarrollo con múltiples personas o en un entorno de producción no debes exponer las credenciales o información sensible con otras personas.

A lo largo del tiempo Rails ha diseñado diferentes estrategias para lidiar con estos datos confidenciales.

Actualmente, se usa el archivo database.yml donde se guarda toda la información respecto a la conexión con la base de datos y el archivo storage.yml, que se usa para guardar credenciales asociadas a servicios de almacenamiento externo. Además usa un sistema de credenciales encriptado mejorado (credentiasl.yml.enc).

Interactuar con el sistema de credenciales

Los archivos database.yml y credentials.yml.enc se encuentran en la carpeta config del proyecto. El archivo credentials esta encriptado por lo que podemos ver el contenido abriendolo normalmente. El archivo database.yml sí no está encriptado por lo que podemos abrirlo sin problema.

Database.yml

Este archivo es creado con la misma aplicación. A pesar de que este archivo es para guardar credenciales, no tiene ningún dato sobre el usuario y la contraseña de la base de datos, porque Rails configura por defecto la conexión y no es necesario un usuario y contraseña.

Credentiasl.yml.enc

Para abrir y editar este archivo se debe ejecutar el comando rails credentials:edit en la terminal. Pero antes hay que especificar con qué editor se abrirá el archivo, de la siguiente forma: EDITOR=nano rails credentials:edit

Dentro del archivo existe una clave ya creada por defecto llamada secret_key_base y tiene como valor un número para establecer esquemas de seguridad.

Dentro de este archivo podemos definir cualquier credencial que queramos guardar de forma encriptada.


Para acceder a los valores de estas credenciales se ejecuta el siguiente comando, que devolverá el valor de la credencial:

# Rails.application.credentials.<nombre>
Rails.application.credentials.hello

Si se quiere mostrar el valor de una credencial en la vista (no es recomendable) se asigna este comando a una variable y se presenta en la vista como cualquier otra.

Para los que esten usando UNIX```js EDITOR=code rails credentials:edit ``` y nos deberia abrir VScode

Puedes especificar el editor que más se adapte a tus gustos. Por ejemplo al usar el comando de abajo…este nos abre las credentials en VScode para modificarlas en el.
Una vez ya modificadas guardas y cierras el archivos, y VOILA! ya modificamos las credenciales utilizando VScode.

EDITOR="code --wait" rails credentials:edit

compañeros recuerden que si sale este mensaje de error al intentar en EDITOR=nano rails credentials:edit
Mensaje de error :
Rails: ActiveSupport::MessageEncryptor::InvalidMessage

Solucion: borramos los archivos
config/master.key
config/credentials.yml.enc
que se crearon por defecto
Ejecutamos
rails credentials:edit
y despues colocamos la linea comando
EDITOR=nano rails credentials:edit
para continuar con el curso
lo que descubrí es que la variable y el valor que colocamos en el editor es que cuando se guarda , este valor también se encripta y si intentas ver el contenido con otro editor de texto no te deja ver lo que agregaste.

Si no te abre el editor al poner este código
EDITOR=nano rails credentials:edit
tienes que instalar nano con apt- install nano

Este es mi aporte del reto pasado.

class WelcomeController < ApplicationController
  def hello
    @my_pet = Pet.first
  end
end
<h1>Hello, my name is: <%= @my_pet.name %> and I'm a <%= @my_pet.breed %>!</h1>