Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)
Apache Cassandra es uno de los sistemas de base de datos distribuidos de código abierto más populares disponibles. Fue diseñado con la meta de manejar grandes cantidades de datos almacenados en muchos servidores distribuidos a lo largo de la geografía mientras proporciona alta escalabilidad y disponibilidad sin ningún punto de falla. Los sistemas Cassandra pueden extender múltiples centros de datos, permitiendo baja latencia para todos los clientes conectados.
Esta es una serie de tres partes de tutorial en donde comenzaré con los básicos de Cassandra, usando CQLSH para crear tablas y registros. Después explicaré los diferentes tipos de datos soportados por Cassandra y después usaremos una librería cliente Go para manejar las operaciones de Cassandra de manera programática.
En esta primera parte, cubriré cómo el modelo de datos de Cassandra es presentado en breve y realiza operaciones básicas usando CQLSH.
Para esta serie de tutoriales, estoy asumiendo que los lectores van a poder instalar Cassandra por si mismos en sus respectivas máquinas dependiendo del sistema operativo.
El Modelo de Datos de Cassandra
El modelo de datos de Cassandra sigue la aproximación de familia de columnas, que puede ser entendida fácilmente como análoga a una estructura de tabla relacional pero no en una manera NoSQL. La descripción de abajo debería hacerlo más claro:
Keyspace
Un keyspace puede ser visto como el contenedor más exterior para datos en Cassandra. Todos los datos en Cassandra deberían vivir dentro de un keyspace. Esto puede ser como una base de datos en RDBMS que es una colección de tablas. En el caso de Cassandra, un keyspace es una colección de familias de columnas.
Familia de Columnas
Una familia de columnas puede ser vista como una colección de filas, y cada fila es una colección de columnas. Es análoga a una tabla en RDBMS pero tiene algunas diferencias. Las familias de columnas son definidas, pero no es necesario para cada fila tener todas las columnas, y las columnas pueden ser agregadas o removidas de una fila como y cuando se requiera.
Columna
La columna es la unidad básica de datos en Cassandra. Tiene tres valores: llave o nombre de columna, valor de columna, y una estampa de tiempo.
Super Columna
Una super columna es un tipo especial de columna que almacena un mapa de otras sub-columnas. Esto hace almacenar datos complejos más fácil y también hace que la recuperación de datos sea más rápida ya que cada familia de columnas en Cassandra es almacenada en una sola fila en el sistema de archivos.
Usando la Consola de Cassandra
CQLSH es la consola estándar para interactuar con Cassandra a través de CQL (Cassandra Query Language). CQL es muy similar a SQL (que es mayormente usado para RDBMS) y por lo tanto hace bastante fácil para desarrolladores nuevos en Cassandra comenzar a trabajar con esta rápidamente. CQLSH es entregado con todos los paquetes Cassandra y ya debería estar instalado en tu máquina cuando instalaste Cassandra.
Crea un Keyspace
Como vimos en el modelo de datos descrito arriba, un keyspace es el contenedor más exterior y debería ser creado antes que cualquier cosa. Para crearlo, ejecuta:
1 |
$ cqlsh localhost -e "CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true;" |
En el comando de arriba, he asumido que tu Cassandra existe en localhost sin ninguna autenticación de usuario. He creado un keyspace llamado k1 con replication y politica durable_writes definida.
Si tienes autenticación de usuario definida, puedes ejecutar:
1 |
$ cqlsh -u <username> -p <password> localhost -e "CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true;" |
En el comando de arriba, reemplaza <username> y <password> con tus credenciales de autenticación.
Ejecutar un comando como este puede ser un poco incómodo. Otra forma es lanzar la consola CQLSH y después ejecutar consultas directamente dentro de esta.
1 |
$ cqlsh -u <username> -p <password> localhost |
2 |
Connected to Test Cluster at 127.0.0.1:9042. |
3 |
[cqlsh 5.0.1 | Cassandra 3.9 | CQL spec 3.4.2 | Native protocol v4]
|
4 |
Use HELP for help.
|
5 |
cassandra@cqlsh> CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; |
Continuando, estaré usando el método de arriba para ejecutar consultas. Antes de ejecutar cualquier otra consulta, necesito decirle a CQLSH cuál keyspace debería ser usado.
1 |
cassandra@cqlsh> USE k1;
|
2 |
cassandra@cqlsh:k1> |
El replication_factor para un keyspace puede ser alterado para ajustar cuando replicación es necesaria por la clase replication.
1 |
cassandra@cqlsh:k1> ALTER KEYSPACE "k1" WITH REPLICATION = |
2 |
{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }; |
Crear y Alterar una Tabla
Una tabla es equivalente a una familia de columnas en Cassandra. Cassandra soporta muchos tipos de datos diferentes para almacenar datos, que estaré cubriendo a detalle en la siguiente parte de esa serie de tutoriales. Para crear una tabla, simplemente ejecuta el comando CREATE TABLE.
1 |
cassandra@cqlsh:k1> CREATE TABLE person (
|
2 |
id text,
|
3 |
name text, |
4 |
surname text, |
5 |
PRIMARY KEY (id)); |
Para revisar cómo la estructura de la tabla luce una vez creada:
1 |
cassandra@cqlsh:k1> DESCRIBE person;
|
2 |
|
3 |
CREATE TABLE k1.person (
|
4 |
id text PRIMARY KEY,
|
5 |
name text, |
6 |
surname text |
7 |
) WITH bloom_filter_fp_chance = 0.01 |
8 |
AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'} |
9 |
AND comment = '' |
10 |
AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'} |
11 |
AND compression = {'chunk_length_in_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'} |
12 |
AND crc_check_chance = 1.0
|
13 |
AND dclocal_read_repair_chance = 0.1
|
14 |
AND default_time_to_live = 0
|
15 |
AND gc_grace_seconds = 864000
|
16 |
AND max_index_interval = 2048
|
17 |
AND memtable_flush_period_in_ms = 0
|
18 |
AND min_index_interval = 128
|
19 |
AND read_repair_chance = 0.0
|
20 |
AND speculative_retry = '99PERCENTILE'; |
Ahora digamos que queremos alterar la tabla para almacenar el email de la persona también.
1 |
cassandra@cqlsh:k1> ALTER TABLE person ADD email text;
|
2 |
cassandra@cqlsh:k1> DESCRIBE person;
|
3 |
|
4 |
CREATE TABLE k1.person (
|
5 |
id text PRIMARY KEY,
|
6 |
email text, |
7 |
name text, |
8 |
surname text |
9 |
) WITH bloom_filter_fp_chance = 0.01 |
10 |
AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'} |
11 |
AND comment = '' |
12 |
AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'} |
13 |
AND compression = {'chunk_length_in_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'} |
14 |
AND crc_check_chance = 1.0
|
15 |
AND dclocal_read_repair_chance = 0.1
|
16 |
AND default_time_to_live = 0
|
17 |
AND gc_grace_seconds = 864000
|
18 |
AND max_index_interval = 2048
|
19 |
AND memtable_flush_period_in_ms = 0
|
20 |
AND min_index_interval = 128
|
21 |
AND read_repair_chance = 0.0
|
22 |
AND speculative_retry = '99PERCENTILE'; |
Insertar y Actualizar Datos
Insertar datos en una tabla Cassandra usando CQL es bastante sencillo.
1 |
cassandra@cqlsh:k1> SELECT * FROM person; |
2 |
|
3 |
id | email | name | surname
|
4 |
----+-------+------+---------
|
5 |
|
6 |
(0 rows) |
7 |
cassandra@cqlsh:k1> INSERT INTO person (id, name, surname, email) VALUES ('001', 'Shalabh', 'Aggarwal', 'contact@shalabhaggarwal.com'); |
8 |
cassandra@cqlsh:k1> SELECT * FROM person; |
9 |
|
10 |
id | email | name | surname
|
11 |
-----+-----------------------------+---------+----------
|
12 |
001 | contact@shalabhaggarwal.com | Shalabh | Aggarwal |
En esta tabla, tenemos todos los campos para solo un tipo de dato. Las cosas se vuelven un poco complejas cuando estamos usando diferentes tipos de datos o tipos de datos compuestos. Esto será una discusión en la siguiente parte de la serie.
Digamos que queremos actualizar el valor en la columna email para algo más.
1 |
cassandra@cqlsh:k1> UPDATE person SET email='shalabh.agrwal@gmail.com' WHERE id='001'; |
2 |
cassandra@cqlsh:k1> SELECT * FROM person; |
3 |
|
4 |
id | email | name | surname
|
5 |
-----+--------------------------+---------+----------
|
6 |
001 | shalabh.agrwal@gmail.com | Shalabh | Aggarwal |
Consultando Datos
Los datos en una tabla pueden ser consultados simplemente usando declaraciones SELECT.
Insertemos algunos registros más y consultemoslos.
1 |
cassandra@cqlsh:k1> INSERT INTO person (id, name, surname, email) VALUES ('002', 'John', 'Doe', 'john@example.com'); |
2 |
cassandra@cqlsh:k1> INSERT INTO person (id, name, surname, email) VALUES ('003', 'Harry', 'Potter', 'harry@example.com'); |
3 |
cassandra@cqlsh:k1> SELECT * from person; |
4 |
|
5 |
id | email | name | surname
|
6 |
-----+--------------------------+---------+----------
|
7 |
002 | john@example.com | John | Doe |
8 |
001 | shalabh.agrwal@gmail.com | Shalabh | Aggarwal |
9 |
003 | harry@example.com | Harry | Potter |
10 |
|
11 |
(3 rows) |
12 |
cassandra@cqlsh:k1> SELECT name FROM person WHERE id='001'; |
13 |
|
14 |
name |
15 |
---------
|
16 |
Shalabh |
17 |
|
18 |
(1 rows) |
19 |
cassandra@cqlsh:k1> SELECT name FROM person WHERE id IN ('001', '002'); |
20 |
|
21 |
name |
22 |
---------
|
23 |
Shalabh |
24 |
John |
25 |
|
26 |
(2 rows) |
Operadores de consulta más complejos como operadores de inequidad también pueden ser usados, o varias condiciones WHERE pueden ser concatenadas usando AND/OR, etc.
Conclusión
Cassandra es uno de los sistemas de bases de datos NoSQL más populares disponibles y es la mejor construcción para ser usada en entornos distribuidos. Lidiar con Cassandra es bastante sencillo para principiantes con algún conocimiento de RDBMS y SQL.
CQL es muy similar a SQL hasta cierto punto, y CQLSH hace las pruebas y la depuración mucho más sencillos. En la siguiente parte de esta serie, cubriré los varios tipos de datos proporcionados por Cassandra y cómo lidiar con ellos.
By
