1. Prerrequisitos

Verificación de Entorno

# Verificar Node.js
node --version
npm --version

# Verificar yarn
yarn --version

# Verificar Docker
docker --version
docker ps

# Instalar si falta (Ubuntu/Debian)
sudo apt update
sudo apt install -y nodejs npm curl

# Instalar yarn globalmente
curl -o- https://yarnpkg.com/install.sh | bash

# Verificar instalación
echo "Node.js: $(node --version)"
echo "Yarn: $(yarn --version)"
echo "Docker: $(docker --version)"

2. Instalación Nativa (Node.js + Yarn)

Clonar Repositorio

# Clonar desde GitHub
git clone https://github.com/scality/cloudserver.git
cd cloudserver

# Verificar estructura del repositorio
ls -la

# Instalar dependencias de JavaScript
yarn install

# Verificar instalación exitosa
ls node_modules | wc -l

# Iniciar CloudServer en puerto 8000
yarn start

Configurar Persistencia (Obligatorio en Producción)

# Crear directorios de persistencia con permisos correctos
mkdir -m 700 /myFavoriteDataPath
mkdir -m 700 /myFavoriteMetadataPath

# Exportar variables de entorno para rutas absolutas
export S3DATAPATH="/myFavoriteDataPath"
export S3METADATAPATH="/myFavoriteMetadataPath"

# Iniciar con persistencia
yarn start

3. Despliegue Docker (Producción)

Docker Pull y Run Básico

# Descargar imagen oficial
docker pull scality/cloudserver

# Ejecutar contenedor con persistencia
docker run -d \
  --name cloudserver \
  -p 8000:8000 \
  -v /ruta/persistencia:/usr/src/app/localData \
  -e S3DATA=/usr/src/app/localData \
  scality/cloudserver

Docker Compose (Ejemplo Completo)

version: '3'
services:
  cloudserver:
    image: scality/cloudserver
    container_name: cloudserver
    ports:
      - "8000:8000"
    volumes:
      - ./data:/usr/src/app/localData
      - ./metadata:/usr/src/app/localMetadata
    environment:
      - S3DATA=/usr/src/app/localData
      - SCALITY_ACCESS_KEY_ID=yourAccessKey
      - SCALITY_SECRET_ACCESS_KEY=yourSecretKey
    healthcheck:
      test: ["CMD", "node", "-e", "require('http').get('http://localhost:8000', (r) => process.exit(r.statusCode === 200 ? 0 : 1)]"
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped
    networks:
      - s3-network

networks:
  s3-network:
    driver: bridge

Docker Compose con Vault (Opcional)

version: '3'
services:
  vault:
    image: hashicorp/vault:1.12
    ports:
      - "8200:8200"
    environment:
      VAULT_ADDR: http://127.0.0.1:8200
      VAULT_ROOT_TOKEN: root
    command: server -dev -listen=0.0.0.0:8200

  cloudserver:
    image: scality/cloudserver
    ports:
      - "8000:8000"
    environment:
      - S3VAULT=vault
      - VAULT_ADDR=http://vault:8200
      - VAULT_TOKEN=root

4. Configuración de Backends

Backend de Memoria (Desarrollo)

# Iniciar con backend in-memory para pruebas
cd cloudserver
yarn run mem_backend

Múltiples Backends

# Configurar múltiples backends
export S3DATA='multiple'
yarn start

Configurar Location Constraints (locationConfig.json)

{
  "locations": {
    "us-east-1": {
      "type": "file",
      "legacyAwsBehavior": false,
      "details": {}
    },
    "eu-west-1": {
      "type": "mem",
      "legacyAwsBehavior": true,
      "details": {}
    }
  },
  "restEndpoints": {
    "localhost": "us-east-1"
  }
}

Tabla de Backends Soportados

5. SSL/HTTPS

Generar Certificados SSL (Self-Signed)

# Generar key para CA
docker exec -it cloudserver bash

# Dentro del contenedor:
openssl genrsa -out ca.key 2048
openssl req -new -x509 -extensions v3_ca \
  -key ca.key -out ca.crt -days 99999 \
  -subj "/C=US/ST=Country/L=City/O=Organization/CN=scality.test"

# Generar key para CloudServer
openssl genrsa -out test.key 2048
openssl req -new -key test.key -out test.csr \
  -subj "/C=US/ST=Country/L=City/O=Organization/CN=*.scality.test"

# Generar certificado firmado por CA
openssl x509 -req -in test.csr -CA ca.crt \
  -CAkey ca.key -CAcreateserial -out test.crt \
  -days 99999 -sha256

Configurar SSL en config.json

{
  "certFilePaths": {
    "key": "./test.key",
    "cert": "./test.crt",
    "ca": "./ca.crt"
  }
}

Configurar /etc/hosts

# Añadir entrada a /etc/hosts (Linux/Mac)
sudo echo "127.0.0.1 s3.scality.test" | sudo tee -a /etc/hosts

# O para Docker Desktop (Windows)
# Editar C:\Windows\System32\drivers\etc\hosts

Test SSL con AWS SDK

const AWS = require('aws-sdk');
const fs = require('fs');
const https = require('https');

const httpOptions = {
  agent: new https.Agent({
    ca: fs.readFileSync('./ca.crt', 'ascii')
  })
};

const s3 = new AWS.S3({
  endpoint: 'https://s3.scality.test:8000',
  sslEnabled: true,
  s3ForcePathStyle: true,
  httpOptions: httpOptions
});

const bucket = 'cocoriko';
s3.createBucket({ Bucket: bucket }, err => {
  if (err) {
    return console.log('Error createBucket', err);
  }
  return s3.deleteBucket({ Bucket: bucket }, err => {
    if (err) {
      return console.log('Error deleteBucket', err);
    }
    return console.log('SSL is cool!');
  });
});

6. Seguridad y Credenciales

Credenciales por Variables de Entorno

# Configurar credenciales seguras
export SCALITY_ACCESS_KEY_ID="yourSecureAccessKey"
export SCALITY_SECRET_ACCESS_KEY="yourSecureSecretKey"
yarn start

Configurar en conf/authdata.json

{
  "users": {
    "accessKey1": {
      "secretAccessKey": "verySecretKey1",
      "policy": "allow-all"
    },
    "yourUser": {
      "secretAccessKey": "yourSecureSecretKey",
      "policy": "read-only"
    }
  }
}

Configurar Vault (Opcional)

# Iniciar con Vault para gestión avanzada de autenticación
export S3VAULT=vault
yarn start

7. Comprobación Posterior

Verificar que el Servidor Está Corriendo

# Verificar proceso
docker ps | grep cloudserver

# O para instalación nativa
ps aux | grep cloudserver

# Test curl básico
curl -X GET http://localhost:8000/

Test con AWS CLI

# Configurar AWS CLI
aws configure

# Crear bucket de prueba
aws s3 mb s3://test-bucket --endpoint-url=http://localhost:8000

# Subir archivo de prueba
aws s3 cp test.txt s3://test-bucket/test.txt \
  --endpoint-url=http://localhost:8000

# Listar objetos
aws s3 ls s3://test-bucket/ \
  --endpoint-url=http://localhost:8000

Test con Python SDK (boto3)

import boto3
from botocore.config import Config

s3 = boto3.client(
    's3',
    endpoint_url='http://localhost:8000',
    aws_access_key_id='accessKey1',
    aws_secret_access_key='verySecretKey1',
    config=Config(signature_version='s3v4')
)

# Crear bucket
s3.create_bucket(Bucket='test-bucket')
print('Bucket creado exitosamente!')

8. Backup y Actualización

Copias de Seguridad (Backup)

# Backup de datos
tar -czf cloudserver-backup-$(date +%Y%m%d-%H%M%S).tar.gz \
  /myFavoriteDataPath

# Backup de metadatos
tar -czf cloudserver-metadata-backup-$(date +%Y%m%d-%H%M%S).tar.gz \
  /myFavoriteMetadataPath

# Backup de configuración
tar -czf cloudserver-config-backup-$(date +%Y%m%d-%H%M%S).tar.gz \
  conf/
  config.json
  locationConfig.json

Actualizar CloudServer

# Actualizar repositorio
cd cloudserver
git pull origin development/9.5

# Reinstalar dependencias
yarn install

# Reiniciar contenedor (Docker)
docker restart cloudserver

# O para instalación nativa
yarn start

Actualizar Imagen Docker

# Pull nueva imagen
docker pull scality/cloudserver:latest

# Reiniciar contenedor con nueva imagen
docker stop cloudserver
docker rm cloudserver
docker run -d \
  --name cloudserver \
  -p 8000:8000 \
  -v /ruta/persistencia:/usr/src/app/localData \
  -e S3DATA=/usr/src/app/localData \
  scality/cloudserver

9. Rollback

Rollback con Docker

# Detener contenedor actual
docker stop cloudserver
docker rm cloudserver

# Restaurar backup de configuración
tar -xzf cloudserver-config-backup-20261005.tar.gz \
  -C /ruta/a/configuracion/

# Reiniciar con configuración restaurada
docker run -d \
  --name cloudserver \
  -p 8000:8000 \
  -v /ruta/persistencia:/usr/src/app/localData \
  -e S3DATA=/usr/src/app/localData \
  scality/cloudserver

Rollback con Instalación Nativa

# Detener proceso actual
killall cloudserver

# Restaurar backup de datos
tar -xzf cloudserver-backup-20261005.tar.gz \
  -C /ruta/a/datos/

# Reiniciar
yarn start

10. Errores Habituales y Soluciones

Debugging Tools

# Ver logs de contenedor
docker logs cloudserver

# Ver logs en tiempo real
docker logs -f cloudserver

# Verificar estado del proceso
systemctl status cloudserver  # systemd
ps aux | grep cloudserver     # manual

11. FAQ (Preguntas Frecuentes)