---
title: "Cómo instalar Chef Infra Server y Workstation en Ubuntu"
description: "Instala Chef Infra Server, configura Chef Workstation con knife, crea un cookbook que despliega Nginx y aplícalo a un nodo nuevo con knife bootstrap en Ubuntu."
category: "Automatización e IaC"
language: es
source: https://cubepath.com/es/docs/automatización-e-iac/instalacion-y-configuracion-de-chef
updated: 2026-09-25
---
# Cómo instalar Chef Infra Server y Workstation en Ubuntu
Chef es una plataforma de gestión de configuración en la que describes el estado de tus servidores con recetas escritas en un DSL de Ruby, agrupadas en cookbooks. Tiene tres piezas: **Chef Infra Server**, que guarda cookbooks y datos de los nodos; **Chef Workstation**, donde escribes el código y usas `knife`; y **Chef Infra Client**, que corre en cada nodo y aplica su configuración. En este tutorial montarás las tres piezas en Ubuntu, crearás un cookbook que instala Nginx y lo aplicarás a un nodo con `knife bootstrap`.
> Nota: Chef es un producto de Progress. Los paquetes oficiales exigen aceptar su licencia y, según la versión y el uso, pueden requerir una clave de licencia. Si necesitas una distribución totalmente libre, **Cinc** (cinc.sh) compila el mismo código fuente sin la marca Chef; los conceptos y la mayoría de comandos de esta guía son iguales, cambiando el prefijo (`cinc-server-ctl`, `cinc-client`).
## Requisitos previos
Necesitas tres máquinas, por ejemplo VPS de CubePath:
- **Chef Infra Server**: Ubuntu LTS de 64 bits soportada por la versión de Chef Infra Server que descargues (consulta su matriz de plataformas), con al menos 4 vCPU y 8 GB de RAM. Chef Server incluye PostgreSQL, OpenSearch y nginx, y no funciona bien con menos memoria.
- **Workstation**: tu equipo con Ubuntu u otra máquina Ubuntu 24.04 desde la que administrarás el resto.
- **Nodo**: un servidor Ubuntu 24.04 limpio al que la workstation pueda acceder por SSH con clave y un usuario con `sudo`.
- El puerto TCP **443** del servidor accesible desde la workstation y el nodo.
Valores de ejemplo:
| Rol | FQDN | IP |
|-----|------|----|
| Chef Infra Server | `chef.example.com` | `server_ip` |
| Workstation | - | `workstation_ip` |
| Nodo | `web01` | `node_ip` |
## Paso 1: Preparar el nombre del servidor
Chef Server genera su certificado TLS y sus URLs a partir del FQDN, así que debe estar fijado antes de instalar. En el **servidor**:
```bash
sudo hostnamectl set-hostname chef.example.com
```
Si no tienes un registro DNS para ese nombre, añádelo a `/etc/hosts` en **el servidor, la workstation y el nodo**:
```bash
sudo nano /etc/hosts
```
```text
server_ip chef.example.com
```
Comprueba que resuelve desde cada máquina:
```bash
getent hosts chef.example.com
```
## Paso 2: Instalar Chef Infra Server
Descarga el paquete `.deb` de **Chef Infra Server** para tu versión de Ubuntu desde la página de descargas oficial de Chef y cópialo al servidor. Instálalo con apt para que resuelva cualquier dependencia:
```bash
sudo apt install ./chef-server-core_*.deb
```
El paquete solo copia los archivos. `reconfigure` configura y arranca todos los servicios internos; la primera vez tarda varios minutos:
```bash
sudo chef-server-ctl reconfigure --chef-license=accept
```
Comprueba que todos los servicios están en marcha:
```bash
sudo chef-server-ctl status
```
```output
run: bookshelf: (pid 2345) 120s; run: log: (pid 2301) 125s
run: nginx: (pid 2410) 118s; run: log: (pid 2398) 120s
run: oc_bifrost: (pid 2201) 130s; run: log: (pid 2190) 131s
run: opscode-erchef: (pid 2460) 115s; run: log: (pid 2450) 116s
run: postgresql: (pid 2101) 140s; run: log: (pid 2099) 141s
...
```
Permite HTTPS desde la workstation y el nodo:
```bash
sudo ufw allow from workstation_ip to any port 443 proto tcp
sudo ufw allow from node_ip to any port 443 proto tcp
```
## Paso 3: Crear el usuario administrador y la organización
Todo en Chef Server pertenece a una organización. Crea primero tu usuario. Con `--prompt-for-password` la contraseña se pide de forma interactiva y no queda en el historial de la shell. La clave privada del usuario se guarda en el archivo indicado con `--filename`:
```bash
sudo mkdir -p /root/chef-keys
sudo chef-server-ctl user-create your_user Nombre Apellido you@example.com --prompt-for-password --filename /root/chef-keys/your_user.pem
```
Crea la organización y asocia a ella tu usuario como administrador:
```bash
sudo chef-server-ctl org-create miorg "Mi Organizacion" --association_user your_user --filename /root/chef-keys/miorg-validator.pem
```
Comprueba que existen:
```bash
sudo chef-server-ctl user-list
sudo chef-server-ctl org-list
```
```output
pivotal
your_user
miorg
```
Solo necesitarás llevar a la workstation la clave del usuario, `your_user.pem`. Cópiala por un canal seguro (por ejemplo con `scp` desde la workstation) y no la dejes en directorios compartidos.
## Paso 4: Instalar y configurar Chef Workstation
En la **workstation**, descarga el paquete `.deb` de **Chef Workstation** para Ubuntu desde la misma página de descargas e instálalo:
```bash
sudo apt install ./chef-workstation_*.deb
```
Comprueba la instalación. La primera ejecución te pide aceptar la licencia:
```bash
chef -v
```
```output
Chef Workstation version: ...
Chef Infra Client version: ...
Chef InSpec version: ...
```
Para llevar tu clave privada a la workstation, primero cópiala en el **servidor** a tu directorio personal con permisos solo para tu usuario (`/root/chef-keys` solo lo puede leer root):
```bash
sudo install -m 600 -o your_user -g your_user /root/chef-keys/your_user.pem ~/your_user.pem
```
Después, en la **workstation**, crea el directorio de configuración de `knife`, descarga la clave y bórrala del directorio personal del servidor:
```bash
mkdir -p ~/.chef
scp your_user@server_ip:your_user.pem ~/.chef/
chmod 600 ~/.chef/your_user.pem
ssh your_user@server_ip rm your_user.pem
```
Crea el archivo de credenciales de `knife`:
```bash
nano ~/.chef/credentials
```
```toml
[default]
client_name = "your_user"
client_key = "/home/your_user/.chef/your_user.pem"
chef_server_url = "https://chef.example.com/organizations/miorg"
```
Chef Server usa un certificado autofirmado. Descárgalo para que `knife` confíe en él y verifica la conexión:
```bash
knife ssl fetch
knife ssl check
```
```output
Connecting to host chef.example.com:443
Successfully verified certificates from `chef.example.com'
```
Por último, prueba una llamada a la API:
```bash
knife client list
```
```output
miorg-validator
```
## Paso 5: Crear un cookbook
Crea un repositorio de trabajo y genera un cookbook llamado `miweb`:
```bash
mkdir -p ~/chef-repo/cookbooks
cd ~/chef-repo/cookbooks
chef generate cookbook miweb
```
El generador crea, entre otros, `metadata.rb` (nombre, versión y dependencias), `recipes/default.rb` y la estructura de tests. Define un atributo con el nombre del sitio, que podrás sobrescribir por nodo o por rol:
```bash
mkdir -p ~/chef-repo/cookbooks/miweb/attributes
nano ~/chef-repo/cookbooks/miweb/attributes/default.rb
```
```ruby
default['miweb']['site_name'] = 'Mi web gestionada con Chef'
```
Escribe la receta. Cada bloque es un recurso que describe un estado deseado; Chef los aplica en orden y solo actúa si el estado real es distinto:
```bash
nano ~/chef-repo/cookbooks/miweb/recipes/default.rb
```
```ruby
package 'nginx'
template '/var/www/html/index.html' do
source 'index.html.erb'
owner 'root'
group 'root'
mode '0644'
variables(site_name: node['miweb']['site_name'])
end
service 'nginx' do
action [:enable, :start]
end
```
Crea la plantilla ERB que usa la receta:
```bash
mkdir -p ~/chef-repo/cookbooks/miweb/templates
nano ~/chef-repo/cookbooks/miweb/templates/index.html.erb
```
```html
<%= @site_name %>
Servidor: <%= node['fqdn'] %>
```
Sube el cookbook al servidor y comprueba que está disponible:
```bash
cd ~/chef-repo
knife cookbook upload miweb --cookbook-path cookbooks
knife cookbook list
```
```output
Uploading miweb [0.1.0]
Uploaded 1 cookbook.
miweb 0.1.0
```
## Paso 6: Registrar el nodo con knife bootstrap
`knife bootstrap` se conecta por SSH al nodo, instala Chef Infra Client, lo registra en el servidor con su propia clave y ejecuta la primera convergencia con la lista de recetas (run list) que indiques:
```bash
knife bootstrap node_ip \
--connection-user your_user \
--ssh-identity-file ~/.ssh/id_ed25519 \
--sudo \
--node-name web01 \
--run-list 'recipe[miweb]' \
--chef-license accept
```
Al final de la salida verás el resumen de la ejecución en el nodo:
```output
[node_ip] Chef Infra Client finished, 3/3 resources updated in 25 seconds
```
> Nota: el bootstrap descarga Chef Infra Client desde los servidores de Chef. Si tu versión o licencia no lo permite, instala antes el paquete de Chef Infra Client (o Cinc Client) en el nodo; `knife bootstrap` detecta que ya está instalado y no lo vuelve a descargar.
## Paso 7: Verificar el resultado
Desde la workstation, comprueba que el nodo está registrado con su run list:
```bash
knife node show web01
```
```output
Node Name: web01
Environment: _default
FQDN: web01
IP: node_ip
Run List: recipe[miweb]
Recipes: miweb, miweb::default
Platform: ubuntu 24.04
```
Y que Nginx sirve la página generada:
```bash
curl -s http://node_ip
```
```output
Mi web gestionada con Chef
Servidor: web01
```
El nombre que aparece es el hostname real del nodo.
Para aplicar cambios futuros, modifica el cookbook, sube la versión en `metadata.rb`, vuelve a ejecutar `knife cookbook upload` y lanza Chef Infra Client en el nodo:
```bash
ssh your_user@node_ip sudo chef-client
```
Si no hay cambios pendientes, la ejecución termina con `0/3 resources updated`: la receta es idempotente.
## Solución de problemas
- **`chef-server-ctl reconfigure` falla o los servicios se reinician continuamente**: suele ser falta de memoria. Revisa `sudo chef-server-ctl tail` y la RAM disponible.
- **`SSL Validation failure connecting to host`**: no has ejecutado `knife ssl fetch` o el nombre de `chef_server_url` no coincide con el FQDN del certificado.
- **`401 Unauthorized` en knife**: `client_name` o `client_key` en `~/.chef/credentials` no corresponden al usuario creado en el servidor.
- **El bootstrap falla al registrar el nodo**: el nodo no resuelve `chef.example.com` o no llega al puerto 443. Comprueba `/etc/hosts` en el nodo y el firewall del servidor.
- **`Node web01 exists` al repetir un bootstrap**: borra el nodo y su cliente antes con `knife node delete web01 -y` y `knife client delete web01 -y`.
## Conclusión
Tienes un Chef Infra Server con una organización, una workstation configurada con `knife` y un nodo gestionado por un cookbook propio. Como siguientes pasos, guarda `~/chef-repo` en Git, prueba los cookbooks con Test Kitchen antes de subirlos, agrupa run lists en roles y programa ejecuciones periódicas de Chef Infra Client en los nodos.