Categories
Hybrid Clouds In detail OpenSource

Desplegando PaaS en un “click"

enter

Siguiendo en la línea del posts sobre Infraestructura como Código (IaC) con la herramienta Terraform, os traemos un nuevo tutorial para desplegar la plataforma de PaaS Rancher de forma totalmente automatizada utilizando RKE.

RKE es el acrónimo de Rancher Kubernetes Engine y se trata de un instalador de Kubernetes escrito en Golang. Es fácil de usar y no requiere mucha preparación por parte del usuario para comenzar.

Como en el tutorial anterior utilizaremos el provider de Terraform para OpenNebula, en esta ocasión utilizaremos una versión mejorada del provider desarrollado por el equipo de Blackberry.

Para acabar recordaros que el próximo 12 y 13 de Noviembre se celebra una nueva edición de la OpenNebulaConf en esta ocasión el lugar elegido a sido Amsterdam y algunos de los miembros de Cloudadmins estaremos allí y participaremos con la ponencia: Hybrid Clouds: Dancing with “Automated” Virtual Machines

Tutorial

Install Terraform

To install Terraform, find the appropriate package for your system and download it

$ curl -O https://releases.hashicorp.com/terraform/0.11.10/terraform_0.11.10_linux_amd64.zip

After downloading Terraform, unzip the package

$ sudo mkdir /bin/terraform
$ sudo unzip terraform_0.11.10_linux_amd64.zip -d /bin/terraform

After installing Terraform, verify the installation worked by opening a new terminal session and checking that terraform is available.

$ export PATH=$PATH:/bin/terraform
$ terraform --version

Add Terraform providers for Opennebula and RKE

You need to install go first: https://golang.org/doc/install
Install Prerequisites

$ sudo apt install bzr

Use the wget command and the link from Go to download the tarball:

$ wget https://dl.google.com/go/go1.10.linux-amd64.tar.gz

The installation of Go consists of extracting the tarball into the /usr/local

$ sudo tar -C /usr/local -xvzf  go1.10.linux-amd64.tar.gz

We will call our workspace directory projects, but you can name it anything you would like. The -p flag for the mkdir command will create the appropriate directory tree

$ mkdir -p ~/projects/{bin,pkg,src}

To execute Go like any other command, we need to append its install location to the $PATH variable.

$ export PATH=$PATH:/usr/local/go/bin

Additionally, define the GOPATH and GOBIN Go environment variables:

$ export GOBIN="$HOME/projects/bin"
$ export GOPATH="$HOME/projects/src"

After go is installed and set up, just type:

$ go get github.com/blackberry/terraform-provider-opennebula
$ go install github.com/blackberry/terraform-provider-opennebula

Post-installation Step

Copy your terraform-provider-opennebula binary in a folder, like /usr/local/bin, and write this in ~/.terraformrc:

$ sudo cp ~/projects/bin/terraform-provider-opennebula /usr/local/bin/terraform-provider-opennebula

For RKE provider, download the binary and copy in the same folder:

$ wget https://github.com/yamamoto-febc/terraform-provider-rke/releases/download/0.5.0/terraform-provider-rke_0.5.0_linux-amd64.zip
$ sudo unzip terraform-provider-rke_0.5.0_linux-amd64.zip -d /usr/local/bin/terraform-provider-rke
providers {
  opennebula = "/usr/local/bin/terraform-provider-opennebula"
}
providers {
  rke = "/usr/local/bin/terraform-provider-rke"
}

Install Rancher

This repository provide a TF file to install Rancher in a high-availability configuration. The goal is easily install a Rancher on machines running CentOS 7.
Clone this repo:

$ git clone https://github.com/mangelft/terraform-rke-paas.git

Create infrastructure

First we have to initialize terraform simply with:

$ terraform init

This will read your configuration files and install the plugins for your provider.
We let terraform create a plan, which we can review:

$ terraform plan

The plan command lets you see what Terraform will do before actually doing it.
Now we execute:

$ terraform apply

terraform-apply
 
oneKubectl is the CLI tool for interacting with the Kubernetes cluster. Please make sure these tools are installed and available.
To make sure it works, run a simple get nodes command.

$ kubectl get nodes

kubectl
 
 
That’s it you should have a functional Rancher server. Point a browser at the hostname: https://rancher.my.org.
 
rancher-dashboard
 

Categories
General In detail OpenSource

Integración continua de infraestructura: Terraform & ONE

ScreenLa Infraestructura como Código (IaC) se está convirtiendo en uno de los elementos clave de los equipos Agile, ya que permite que la infraestructura ya no sea el cuello de botella dentro de nuestro pipeline CI/CD.
Una de las herramientas que se puede utilizar es terraform. Esta aplicación permite codificar la infraestructura según las necesidades del servicio y hacerlo de manera agnóstica al entorno cloud donde se ejecute. Por ello, la IaC nos puede ayudar a agilizar la creación y mantenimiento de infraestructuras de forma automatizada.
Dentro de la comunidad de la plataforma abierta de computación en la nube,  OpenNebula, Runtastic ha desarrollado un provider de OpenNebula para terraform, aprovechando la API OpenNebula XML/RPC. Este proveedor permite crear los principales recursos de OpenNebula, como una máquina virtual, un template, una red virtual o una imagen de disco.
En el siguiente tutorial, se detalla como instalar la herramienta i utilizarla con OpenNebula para desplegar un clúster de Kubernetes sobre Docker de forma totalmente automatizada con Terraform y Ansible.
Por último, recordaros que el próximo 24 de mayo, vuelve el “OpenNebula TechDay“,  a Barcelona que constará de un taller práctico donde se presentará esta plataforma, y se procederá a su instalación y se mostrará su funcionamiento y sus utilidades.
Ya podéis registraros al evento en el siguiente enlace! Y en breve tendréis también disponible la Agenda para la Jornada.

Tutorial

Deploying a Kubernetes Cluster to ONE with Ansible and Terraform

 Installing Terraform

To install Terraform, find the appropriate package for your system and download it

$ curl -O https://releases.hashicorp.com/terraform/0.11.4/terraform_0.11.4_linux_amd64.zip

After downloading Terraform, unzip the package

$ sudo mkdir /bin/terraform
$ sudo unzip terraform_0.11.4_linux_amd64.zip -d /bin/terraform

After installing Terraform, verify the installation worked by opening a new terminal session and checking that terraform is available.

$ export PATH=$PATH:/bin/terraform
$ terraform --version

Installing Terraform provider Opennebula

You need to install go first: https://golang.org/doc/install

Install Prerequisites
$ sudo apt install bzr

Use the wget command and the link from Go to download the tarball:

$ wget https://dl.google.com/go/go1.10.linux-amd64.tar.gz

The installation of Go consists of extracting the tarball into the /usr/local
 

$ sudo tar -C /usr/local -xvzf  go1.10.linux-amd64.tar.gz

We will call our workspace directory projects, but you can name it anything you would like. The `-p` flag for the `mkdir` command will create the appropriate directory tree

$ mkdir -p ~/projects/{bin,pkg,src}

To execute Go like any other command, we need to append its install location to the $PATH variable.

$ export PATH=$PATH:/usr/local/go/bin

Additionally, define the GOPATH and GOBIN Go environment variables:

$ export GOBIN="$HOME/projects/bin"
$ export GOPATH="$HOME/projects/src"

After go is installed and set up, just type:

$ go get github.com/runtastic/terraform-provider-opennebula
$ go install github.com/runtastic/terraform-provider-opennebula
Optional post-installation Step

Copy your terraform-provider-opennebula binary in a folder, like /usr/local/bin, and write this in ~/.terraformrc:

$ sudo cp ~/projects/bin/terraform-provider-opennebula /usr/local/bin/terraform-provider-opennebula

Example for /usr/local/bin:

providers {
  opennebula = "/usr/local/bin/terraform-provider-opennebula"
}
Install Ansible

We can add the Ansible PPA by typing the following command:

$ sudo apt-add-repository ppa:ansible/ansible

Next, we need to refresh our system’s package index so that it is aware of the packages available in the PPA. Afterwards, we can install the software:

$ sudo apt-get update
$ sudo apt-get install ansible

Deploy a Kubernetes cluster

Terraform code is written in a language called HCL in files with the extension “.tf”. It is a declarative language, so your goal is to describe the infrastructure you want, and Terraform will figure out how to create it. This repository provide an Ansible playbook to Build a Kubernetes cluster with kubeadm. The goal is easily install a Kubernetes cluster on machines running CentOS 7. 

$ git clone https://github.com/mangelft/terransible-kubernetes-cluster.git

First, initialize Terraform for your project. This will read your configuration files and install the plugins for your provider:

$ terraform init


In a terminal, go into the folder where you created main.tf, and run the terraform plan command:

The plan command lets you see what Terraform will do before actually doing it. To actually create the instance, run the terraform apply command:


You can access Dashboard using the kubectl command-line tool by running the following command:

$ kubectl proxy --address $MASTER_IP --accept-hosts='^*$'


The last step is to complete the cluster life cycle by removing your resources, do: terraform destroy

 Fuente: https://github.com/mangelft/terransible-kubernetes-cluster

Buen vuelo!

Categories
General In detail OpenSource

Docker Swarm y Consul con OpenNebula

Como continuación al post publicado sobre Docker Machine y OpenNebula, en esta ocasión veremos que con dicho driver también podemos implementar la funcionalidad de Docker Swarm.
docker-swarm-opennebula
Docker Swarm tiene la capacidad de balancear según la disponibilidad del clúster. Así pues, si por ejemplo en un clúster hay un contenedor y este deja de estar disponible, Swarm encarga de asignarlo a otro nodo disponible.
Para  poder implementar esta funcionalidad, hace falta tener instalado Docker Engine y Docker Machine con el driver para a OpenNebula.

Tutorial

El primer paso será crear una máquina virtual con Docker Engine para el servicio de discovery con Consul y arrancar un contenedor con consul:

docker-machine create -d opennebula --opennebula-network-id $network_id --opennebula-image-id $b2d_image_id --opennebula-b2d-size $volatile_disk_size consul
docker $(docker-machine config consul) run -d -p "8500:8500" -h "consul" progrium/consul -server -bootstrap
CONSUL_IP=$(docker-machine ip consul)

Podemos verificar que funciona correctamente, accediendo a la IP de la máquina por el puerto 8500:
consul
 
 
 
 
 
 
 
 
 
 
 
Creamos una nueva máquina virtual, para el nodo máster del clúster:

docker-machine create -d opennebula --opennebula-network-id $network_id --opennebula-image-id $b2d_image_id --opennebula-b2d-size $volatile_disk_size --swarm --swarm-master --swarm-discovery="consul://$CONSUL_IP:8500" --engine-opt cluster-store=consul://$CONSUL_IP:8500 --engine-opt cluster-advertise="eth0:2376" swarm-master

Y tantas máquinas virtuales como nodos queramos que tenga nuestro clúster:

docker-machine create -d opennebula --opennebula-network-id $network_id --opennebula-image-id $b2d_image_id --opennebula-b2d-size $volatile_disk_size --swarm --swarm-discovery="consul://$CONSUL_IP:8500" --engine-opt cluster-store=consul://$CONSUL_IP:8500 --engine-opt cluster-advertise="eth0:2376" swarm-node-XX

opennebula_docker_machine1

docker-machine ls

docker_machine_ls1
 
 
Una vez tengamos creados los nodos que compondrán el clúster, podemos acceder al nodo máster con la siguiente comanda:

eval $(docker-machine env --swarm swarm-master)

Podemos ver la información y estado del clúster con el comando:

docker info

eval_info2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
También existe la opción de poder crear redes privadas dentro del clúster usuando el driver overlay:

docker network create --driver overlay --subnet=10.0.1.0/24 overlay_net
docker network ls

Una vez, tenemos el clúster en marcha, ya podemos utilizar Docker de la forma habitual:

docker pull nginx
docker run --name mynginx -d -p 80:80 nginx

nginx
 
 
nginx21
 
 
Siguiente paso… automatizar la elasticidad del clúster con OneFlow.
 
 
 

Categories
General In detail OpenSource

Docker Machine con el driver de OpenNebula

Siguiendo con la serie de posts sobre Docker, en esta ocasión os presentamos el driver de Docker Machine para OpenNebula, con el que podremos crear máquinas virtuales con Docker dentro de nuestra plataforma cloud.
docker_opennebula
Los requisitos para poder utilizar el driver son los siguientes:

  • Docker Machine 0.5+
  • OpenNebula 4.x+

Para la instalación del plugin basta con seguir todos los pasos descritos en la URL del repositorio:
https://github.com/OpenNebula/docker-machine-opennebula

Como utilizar el driver de OpenNebula con Docker Machine:

Para utilizar el driver sólo necesitaremos disponer de acceso a un cloud con OpenNebula i configurar las variables de entorno ONE_AUTH y ONE_XMLRPC para que apunten a nuestro cloud OpenNebula y una imagen ya preparada con Docker Engine.
OpenNebula dispone de dos imágenes en modo appliance que se pueden importar desde su marketplace:

Una vez dispongamos de la imagen con Docker Engine, ya podemos levantar una màquina virtual con el driver de Docker Machine para OpenNebula, con la ejecución del siguiente comando:

docker-machine  create --driver opennebula --opennebula-network-id $NETWORK_ID --opennebula-image-name boot2docker --opennebula-image-owner oneadmin --opennebula-b2d-size 10240 mydockerengine

one-docker-1
 
 
 
 
 
 
 
 
 
 
 
Podemos personalizar el comando con los siguientes parámetros:

--opennebula-cpu: CPU value for the VM
--opennebula-vcpu: VCPUs for the VM
--opennebula-memory: Size of memory for VM in MB
--opennebula-template-id: Template ID to use
--opennebula-template-name: Template to use
--opennebula-network-id: Network ID to connect the machine to
--opennebula-network-name: Network to connect the machine to
--opennebula-network-owner: User ID of the Network to connect the machine to
--opennebula-image-id: Image ID to use as the OS
--opennebula-image-name: Image to use as the OS
--opennebula-image-owner: Owner of the image to use as the OS
--opennebula-dev-prefix: Dev prefix to use for the images: 'vd', 'sd', 'hd', etc...
--opennebula-disk-resize: Size of disk for VM in MB
--opennebula-b2d-size: Size of the Volatile disk in MB (only for b2d)
--opennebula-ssh-user: Set the name of the SSH user
--opennebula-disable-vnc: VNC is enabled by default. Disable it with this flag

Ahora lo que haremos será conectar nuestra shell local a la de la máquina virtual para que cada vez que ejecutamos un comando de Docker, este dé órdenes al Docker Engine instalado en la máquina virtual de OpenNebula.
Obtenemos las variables de entorno de la máquina virtual.

docker-machine env mydockerengine

Link  a la shell.

eval "$(docker-machine env mydockerengine)"

Con esto ya podemos empezar a utilizar docker sobre la máquina virtual  que acabamos de crear:

docker pull nginx
docker run --name mynginx -d -p 80:80 ngin

image2016-3-16 19-21-38

Categories
General In detail

Docker for Dummies

Qué es Docker?

DockerLogo
Docker es un proyecto open-source que permite automatizar el despliegue de aplicaciones en entornos Linux. Está basado en el formato estándar de contenedores de Linux(LXC) y permite correr aplicaciones en ambientes aislados de manera ligera. Docker nos permite crear “imágenes” con nuestra aplicación y sus dependencias, garantizando que ésta funcionará, a escala, en producción o en cualquier otro ambiente. De esta manera evitamos el llamado “dependency hell” y facilitamos el desarrollo y mantenimiento de las aplicaciones.
A diferencia de las máquinas virtuales tradicionales, un contenedor Docker no incluye un sistema operativo independiente, sino que se basa en la funcionalidad del sistema operativo proporcionado por la infraestructura subyacente. Esto es gracias a usar contenedores de Linux (LXC), ya que corren sobre el mismo sistema operativo que el mismo host. Además usa AuFS1 para sistema de archivos y se encarga de las redes por los usuarios.
docker4
A continuación se presentan dos tutoriales para iniciarse con Docker y ver todas las possibilidades que ofrece el entorno. Para los tutoriales se ha utilizado la herramienta Docker Toolbox.
 
docker1
docker2

Tutorial 1: OpenLDAP / PhpLdapAdmin

Buscamos la imagen que nos interese, en nuestro caso OpenLdap, con el siguiente comando:

docker search openldap

Luego podemos descargar la imagen con el comando:

docker pull osixia/openldap

Una vez finalizada la descarga podemos consultar las imágenes que tenemos disponibles con el comando:

docker images

Cuando tenemos la imagen disponible ya podemos instanciar un contenedor:

docker –-name myldap run --env LDAP_ORGANISATION="CloudAdmins" --env LDAP_DOMAIN="cloudadmins.org" --env LDAP_ADMIN_PASSWORD="Admin" --detach osixia/openldap

Este comando lo que realiza es levantar un contenedor con los siguientes parámetros
–name el nombre asociado al contenedor
–env para definir varias variables de entorno que configuraran nuestro LDAP
Podemos comprobar los contenedores que están levantados, con el comando:

docker ps -a

También podemos obtener una Shell del contenedor con el comando:

docker exec -it myldap bash

o ejecutar comandos sobre el contenedor:

docker exec myldap ldapsearch -h localhost -D "cn=admin,dc=cloudadmins,dc=org" -w Admin

 
Para instanciar un contenedor con phpldapadmin realizamos la misma operación:

docker search phpldapadmin
docker pull osixia/phpldapadmin

Con el siguiente comando podemos obtener la IP del contenedor donde hemos instanciado nuestro LDAP:

docker inspect --format '{{ .NetworkSettings.IPAddress }}' myldap

Finalmente, podemos instanciar el contenedor para administrar nuestro LDAP con phpldapadmin:

docker run -p 443:443 -e PHPLDAPADMIN_LDAP_HOSTS=172.17.0.2 -d osixia/phpldapadmin

Y así de una forma rápida tendríamos disponible nuestro servidor LDAP:
docker3
Podemos parar un contenedor:

docker stop myldap

Para borrar un contenedor deberíamos ejecutar el siguiente comando

docker rm myldap

Por último, para borrar la imagen descargada de Openldap, ejecutaríamos el comando:

docker rmi osixia/openldap

Tutorial 2: Crear una imagen desde un fichero Dockerfile

Un fichero Dockerfile es simplemente un fichero de texto que nos permite definir las instrucciones a seguir por Docker para construir una imagen.
En este ejemplo vamos a crear una imagen con un SO Centos 7 y le vamos a instalar el servidor web Apache:

FROM centos:latest
MAINTAINER http://www.centos.org
RUN yum -y update && yum clean all
RUN yum -y install httpd && yum clean all
EXPOSE 80
RUN rm -rf /run/httpd/* /tmp/httpd*
ENTRYPOINT /usr/sbin/apachectl -D FOREGROUND

RUN: Ejecuta una sentencia sobre la imagen base
EXPOSE: Expone el puerto 80 del contenedor para que pueda ser mapeado por la máquina anfitrión.
ENTRYPOINT: Indicamos que se ejecute apache2ctl -D FOREGROUND cada vez que arranquemos el contenedor.
Construimos la imagen con el comando:

docker build -t cloudadmins/centos7-httpd --file <DOCKERFILE_NAME> .

Finalmente, instanciamos nuestro contenedor con el comando:

docker run -d --name cloudadmins -p 80:80 -v <PATH_HOST>/www:/var/www/html cloudadmins/centos7-httpd

En esta ocasión hemos utilizado el parámetro -v para que el directorio /var/www/html del contenedor, sea el indicado en el comando de la máquina anfitrión.
 

Referencias i recursos

http://inlab.fib.upc.es/es/blog/docker-insights-des-de-la-jasp
http://media.fib.upc.edu/fibtv/streamingmedia/view/2/1128
 

Categories
Community General OpenSource Social

OpenNebula Conf 2015

Como ya os veníamos anunciando, entre los días 20 – 22 de octubre, tuvo lugar la tercera edición de la OpenNebula Conf que este año se celebraba en Barcelona en el Hotel Barceló Sants .
El evento comenzó con las ya tradicionales sesiones de “Hands On” y “Hacking Session”, en la primera se enseña a los asistentes a instalar desde cero la plataforma de OpenNebula y así los usuarios pueden comenzar a familiarizarse con ella y les permite llevarse su propio “Cloud” a casa. La segunda más enfocada a usuarios que ya están acostumbrados a trabajar con la plataforma es un punto de encuentro con los desarrolladores donde se puede plantear aquellos problemas del día a día del uso de la plataforma o aquellas cosas que serían interesantes incorporar para mejorarla. Entre los temas más demandados de este año se encontraban: Cloud bursting, integración con Ceph, HA, monitorización, autentificación o personalización de drivers.
El primer día también tenía el atractivo de contar en una de las salas con la Centos Dojo , las sesiones se basaron en temas como: Automatización de servicios con Foreman, “Customización” de imágenes de máquinas virtuales o Xen tuning. Podéis consultar todas las sesiones en el canal de YouTube de TheCentOSProject
Los días siguientes consistieron en pequeñas conferencias de unos 20 o 30 minutos cada una. Donde cada una de las organizaciones participantes presentaba su experiencia y como le había ayudado OpenNebula compartiendo así sus conocimientos sobre la plataforma y las tecnologías que estaban utilizando.
Cloudadmins estuvo representado por @jordiguijarro, en una charla sobre como OpenNebula ha sido una pieza importante en los laboratorios de innovación dentro del proyecto europeo DC4cities. Y aprovechó la ocasión para presentar entre los asistentes el grupo de usuarios de OpenNebula de Barcelona.
IMG_20151102_221031
La conferencia finalizó con una presentación a cargo del equipo de desarolladores de OpenNebula Systems donde nos mostraron su próximo Roadmap.
IMG_20151102_222512
Por supuesto también hubo tiempo para algunos eventos de ocio a modo de “Networking” que tuvieron lugar en los restaurantes “La Taberna del Cura” y la Fàbrica Moritz.
20151021_213443
Así que ya sabías, os esperamos en la próxima OpenNebula Conf…

Categories
General OpenSource

OpenNebula Barcelona User Group en Sudoers

El pasado 5 de mayo tuvo lugar la puesta de largo del grupo OpenNebula Barcelona User Group en la Sudoers realizada en el Campus Nord de la Universitat Politècnica de Catalunya (UPC).

El evento se inició con una presentación sobre la herramienta de automatización SaltStack a cargo de @xmorueco, donde se pudo ver la utilidad de este tipo de soluciones y como pueden facilitar el día a día de los DevOps.

Seguidamente, Xavier Peralta realizó una presentación introductoria a OpenNebula, comenzando por una visión general sobre la plataforma, un repaso por sus principales componentes i características, así como sus principales funcionalidades, entre ellas realizó una interesante demostración de la funcionalidad de auto-escalado de la plataforma.

XP_Sudoers

Finalmente, @jordiguijarro presentó en la sesión el grupo de reciente creación OpenNebula Barcelona User Group, dando a conocer cuáles serán los futuros pasos del grupo y en qué proyectos está trabajando actualmente, donde animó a los asistentes a unirse a él y adelantó que la próxima conferencia OpenNebula Cloud tendrá lugar en Barcelona entre los días 20-22 de Octubre y que se realizará un sorteo de un pase para los tres días entre todos los integrantes del grupo, recibiréis más información en un post específico así que atentos al blog.

JGO-Sudoers

Os recordamos que podéis solicitar formar parte del grupo a través del siguiente enlace:

http://www.cloudadmins.org/opennebula-barcelona-usergroup/

Desde CloudAdmins os animamos a uniros al grupo.

Categories
Bigdata General NoSQL

Construye tu propio Cloud Storage con Riak CS

Riak CS es una solución Open Source, desarrollada por Basho, que te permite montar tu propio servicio de almacenamiento en la nube, de manera similar a los servicios S3 de Amazon.

Riak CS permite crear tanto nubes públicas como privadas de almacenamiento y está basado en una base de datos de código abierto NoSQL.
Los principales puntos fuertes de la solución son:

  • Almacenamiento tolerante a fallos en alta disponibilidad.
  • Soporte para almacenar objetos de gran tamaño.
  • API compatible-S3 y autenticación.
  • Multi-tenancy y presentación de informes por usuario.
  • Modelo operativo simple para añadir capacidad, altamente escalable.
  • Estadísticas sólidas para el seguimiento y métricas.

En la web de Basho, disponemos de documentación especifica (Riak CS Fast Track) para construir un entorno virtual rápidamente utilizando Vagrant Chef y así poder probar y testear la solución.

Una vez desplegado, simplemente necesitaremos un cliente de S3, por ejemplo: s3cmd, para interaccionar con el entorno.
Interaccionar con Riak CS a través de s3cmd

  • Crear un bucket de pruebas
s3cmd mb s3://test-bucket
  • Listar el contenido de un bucket
s3cmd ls s3://test-bucket
  • Subir un fichero al bucket
dd if=/dev/zero of=test_file bs=1m count=2 # Create a test file
s3cmd put test_file s3://test-bucket
  • Obtener o descargar un fichero del bucket
s3cmd get s3://test-bucket/test_file

En definitiva, Riak CS se presenta como una buena alternativa al Object Storage (Swift) de OpenStack.
En la web de Basho se puede consultar documentación adicional del proyecto, tanto de Riak como de Riak CS, así como otros proyectos creados a partir de Riak: