{"id":5089,"date":"2018-05-08T09:00:31","date_gmt":"2018-05-08T16:00:31","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=5089"},"modified":"2025-06-13T18:45:29","modified_gmt":"2025-06-14T01:45:29","slug":"using-graphql-with-golang-and-a-nosql-database","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/es\/using-graphql-with-golang-and-a-nosql-database\/","title":{"rendered":"Uso de GraphQL con Golang y una base de datos NoSQL"},"content":{"rendered":"

Hace unas semanas hab\u00eda mencionado que estaba aprendiendo sobre el cada vez m\u00e1s popular GraphQL y c\u00f3mo puede ser un reemplazo a la API RESTful com\u00fan. En mi ejemplo anterior<\/a>vimos c\u00f3mo crear una aplicaci\u00f3n GraphQL utilizando Node.js y una aplicaci\u00f3n Couchbase<\/a> Base de datos NoSQL<\/a>. Sin embargo, soy tan fan del lenguaje de programaci\u00f3n Go como de Node.js.<\/p>\n

Vamos a ver c\u00f3mo crear una aplicaci\u00f3n con Golang que pueda crear y consultar datos utilizando Consultas GraphQL<\/a> en lugar de varios puntos finales de API RESTful.<\/p>\n

<\/p>\n

Si no est\u00e1s familiarizado con GraphQL, funciona pasando consultas desde un front-end al back-end y obteniendo de vuelta s\u00f3lo los datos que has solicitado, independientemente de su procedencia o complejidad, en lugar de consumir datos de cualquier n\u00famero de puntos finales de API potencialmente no relacionados. De este modo, se reducen tanto las solicitudes como la carga de datos, lo que agiliza el proceso y lo hace m\u00e1s eficiente.<\/p>\n

Primeros pasos con GraphQL y Golang<\/h2>\n

Al igual que con una API RESTful, la mayor parte de una aplicaci\u00f3n GraphQL consistir\u00e1 en la configuraci\u00f3n. Sin embargo, menos de una aplicaci\u00f3n GraphQL depender\u00e1 de la planificaci\u00f3n, que es diferente de una API RESTful que requiere una planificaci\u00f3n pesada con el fin de seguir siendo f\u00e1cil de usar.<\/p>\n

Necesitamos instalar una dependencia del paquete GraphQL para Golang antes de poder continuar. Desde la l\u00ednea de comandos, ejecute lo siguiente:<\/p>\n

go get github.com\/graphql-go\/graphql<\/pre>\n
Con nuestra dependencia disponible, cree un nuevo proyecto dentro de su\u00a0$GOPATH<\/strong>. Dentro de ese proyecto, cree un archivo llamado\u00a0main.go<\/strong> e incluir lo siguiente que ser\u00e1 nuestra base de aplicaci\u00f3n:<\/p>\n
package main\r\n\r\nimport (\r\n\t\"encoding\/json\"\r\n\t\"fmt\"\r\n\t\"log\"\r\n\t\"net\/http\"\r\n\t\"github.com\/graphql-go\/graphql\"\r\n)\r\n\r\ntype Account struct {\r\n\tID        string `json:\"id,omitempty\"`\r\n\tFirstname string `json:\"firstname\"`\r\n\tLastname  string `json:\"lastname\"`\r\n\tType      string `json:\"type\"`\r\n}\r\n\r\ntype Blog struct {\r\n\tID      string `json:\"id,omitempty\"`\r\n\tAccount string `json:\"account\"`\r\n\tTitle   string `json:\"title\"`\r\n\tContent string `json:\"content\"`\r\n\tType    string `json:\"type\"`\r\n}\r\n\r\nfunc main() {\r\n\tfmt.Println(\"Starting application...\")\r\n\taccountType := graphql.NewObject(graphql.ObjectConfig{\r\n\t\tName: \"Account\",\r\n\t\tFields: graphql.Fields{},\r\n\t})\r\n\tblogType := graphql.NewObject(graphql.ObjectConfig{\r\n\t\tName: \"Blog\",\r\n\t\tFields: graphql.Fields{},\r\n\t})\r\n\trootQuery := graphql.NewObject(graphql.ObjectConfig{\r\n\t\tName: \"Query\",\r\n\t\tFields: graphql.Fields{},\r\n\t})\r\n\trootMutation := graphql.NewObject(graphql.ObjectConfig{\r\n\t\tName: \"RootMutation\",\r\n\t\tFields: graphql.Fields{},\r\n\t})\r\n\tschema, _ := graphql.NewSchema(graphql.SchemaConfig{\r\n\t\tQuery:    rootQuery,\r\n\t\tMutation: rootMutation,\r\n\t})\r\n\thttp.HandleFunc(\"\/graphql\", func(w http.ResponseWriter, r *http.Request) {\r\n\t\tresult := graphql.Do(graphql.Params{\r\n\t\t\tSchema:        schema,\r\n\t\t\tRequestString: r.URL.Query().Get(\"query\"),\r\n\t\t})\r\n\t\tjson.NewEncoder(w).Encode(result)\r\n\t})\r\n\thttp.ListenAndServe(\":8080\", nil)\r\n}<\/pre>\n
Nuestro plan es crear una aplicaci\u00f3n que pueda crear y consultar cuentas, as\u00ed como crear y consultar entradas de blog para cualquier cuenta en particular. El modelo de datos de nuestra aplicaci\u00f3n est\u00e1 definido por el m\u00f3dulo\u00a0Cuenta<\/code> y la estructura Blog<\/code> estructuraci\u00f3n. Este modelo de datos ayudar\u00e1 a alimentar nuestro modelo de datos de base de datos, as\u00ed como nuestro modelo de datos GraphQL.<\/p>\n
Cuando se trata de la configuraci\u00f3n GraphQL, te dar\u00e1s cuenta de que hay algunos objetos creados. El accountType<\/code> y el blogTipo<\/code> representan el modelo de datos GraphQL que se crear\u00e1 alrededor de los Go structs. A\u00fan no est\u00e1n configurados, pero lo estar\u00e1n. El rootQuery<\/code> ser\u00e1 el conjunto de consultas que podemos ejecutar y el rootMutation<\/code> ser\u00e1 cualquier mutaci\u00f3n de cambio de datos que se pueda ejecutar. Con GraphQL, no est\u00e1s limitado a solo leer datos.<\/p>\n
El esquema GraphQL nos permite definir qu\u00e9 son consultas y qu\u00e9 son mutaciones. Esto es necesario para cuando queramos consumir consultas. Aunque no estamos creando una API RESTful, seguimos necesitando un endpoint HTTP. Este \u00fanico \/graphql<\/code> se encargar\u00e1 de todas las consultas y mutaciones y se alimenta del esquema.<\/p>\n
Antes de conectar la base de datos, podemos definir nuestro esquema GraphQL:<\/p>\n
accountType := graphql.NewObject(graphql.ObjectConfig{\r\n    Nombre \"Cuenta\",\r\n    Campos: graphql.Campos{\r\n        \"id\": &graphql.Campo{\r\n            Tipo: graphql.String,\r\n        },\r\n        \"firstname\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n        \"apellido\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n    },\r\n})\r\nblogType := graphql.NewObject(graphql.ObjectConfig{\r\n    Nombre: \"Blog\",\r\n    Campos: graphql.Campos{\r\n        \"id\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n        \"cuenta\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n        \"title\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n        \"content\": &graphql.Field{\r\n            Tipo: graphql.String,\r\n        },\r\n    },\r\n})<\/pre>\n
F\u00edjate que s\u00f3lo estamos definiendo nombres de propiedades y su correspondiente tipo de datos. Te dije que ser\u00eda bastante similar a como hemos definido las estructuras de datos en Go.<\/p>\n
Ahora vamos a centrarnos en cargar nuestro esquema con datos de Couchbase Server.<\/p>\n
Consulta de datos de una base de datos NoSQL con GraphQL<\/h2>\n
Por ahora no hemos hecho ninguna preparaci\u00f3n de la base de datos. El objetivo de este tutorial no es configurar Couchbase. Necesitar\u00e1s Couchbase Server disponible con soporte N1QL, un Bucket, algunos \u00edndices y una cuenta de control de acceso basada en roles para la aplicaci\u00f3n.<\/p>\n
Desde la l\u00ednea de comandos, ejecute las siguientes l\u00edneas para obtener nuestros paquetes de base de datos:<\/p>\n
go get github.com\/satori\/go.uuid\r\ngo get gopkg.in\/couchbase\/gocb.v1<\/pre>\n
Los comandos anteriores nos conseguir\u00e1n un paquete para crear valores UUID para claves de documentos, as\u00ed como el SDK de Couchbase Go.<\/p>\n
Ignorando todo lo que ya le hemos hecho a nuestro\u00a0main.go<\/strong> eche un vistazo al siguiente c\u00f3digo y aj\u00fastelo a lo que tiene donde tenga sentido:<\/p>\n
package main\r\n\r\nimport (\r\n\t\"encoding\/json\"\r\n\t\"fmt\"\r\n\t\"log\"\r\n\t\"net\/http\"\r\n\t\"github.com\/graphql-go\/graphql\"\r\n\tuuid \"github.com\/satori\/go.uuid\"\r\n\tgocb \"gopkg.in\/couchbase\/gocb.v1\"\r\n)\r\n\r\nvar bucket *gocb.Bucket\r\n\r\nfunc main() {\r\n\tfmt.Println(\"Starting application...\")\r\n\tcluster, err := gocb.Connect(\"couchbase:\/\/localhost\")\r\n\tif err != nil {\r\n\t\tlog.Fatal(err)\r\n\t}\r\n\tcluster.Authenticate(gocb.PasswordAuthenticator{Username: \"example\", Password: \"123456\"})\r\n\tbucket, err = cluster.OpenBucket(\"example\", \"\")\r\n\tif err != nil {\r\n\t\tlog.Fatal(err)\r\n\t}\r\n}<\/pre>\n
Observa que hemos definido un Bucket que utilizaremos cuando interactuemos con la base de datos. Nos estamos conectando a un cluster de Couchbase en el directorio principal<\/code> autentic\u00e1ndose con una cuenta RBAC, y abriendo un Bucket, todo lo cual deber\u00eda haber sido definido antes de comenzar este tutorial.<\/p>\n
Supongamos que ya tienes datos en tu base de datos. Vamos a empezar por intentar consultar los datos. \u00bfRecuerdas el siguiente trozo de c\u00f3digo que se a\u00f1adi\u00f3 anteriormente?<\/p>\n
rootQuery := graphql.NewObject(graphql.ObjectConfig{\r\n    Name: \"Query\",\r\n    Fields: graphql.Fields{ },\r\n})<\/pre>\n
Cada campo existir\u00e1 como un campo en Campos<\/code> propiedad. Digamos que queremos obtener todas las cuentas de nuestra base de datos.<\/p>\n
\"cuentas\": &graphql.Campo{\r\n    Tipo: graphql.NewList(accountType),\r\n    Resolve: func(p graphql.ResolveParams) (interfaz{}, error) {\r\n        query := gocb.NewN1qlQuery(\"SELECT META(cuenta).id, cuenta.* FROM ejemplo COMO cuenta WHERE cuenta.tipo = 'cuenta'\")\r\n        rows, err := bucket.ExecuteN1qlQuery(query, nil)\r\n        if err != nil {\r\n            return nil, err\r\n        }\r\n        var accounts []Cuenta\r\n        var fila Cuenta\r\n        for filas.Siguiente(&fila) {\r\n            cuentas = append(cuentas, fila)\r\n        }\r\n        return cuentas, nil\r\n    },\r\n},<\/pre>\n
En el c\u00f3digo anterior estamos creando un campo GraphQL llamado cuentas<\/code> que devolver\u00e1 una lista de accountType<\/code> cuando se ejecuta. La direcci\u00f3n Resolver<\/code> es la que hace el trabajo pesado. Opcionalmente podemos pasar par\u00e1metros de consulta, pero para este campo en particular no lo estamos haciendo. Al intentar consultar las cuentas, estamos creando una consulta N1QL que devuelve todas las propiedades y resultados posibles. La consulta GraphQL determinar\u00e1 cu\u00e1les de esas propiedades y resultados llegan al cliente.<\/p>\n
Tomemos la siguiente consulta frontal que puede ejecutarse:<\/p>\n
{\r\n    accounts {\r\n        id,\r\n        firstname\r\n    }\r\n}<\/pre>\n
Mientras que podr\u00edamos conseguir el id<\/code>, nombre<\/code>y apellido<\/code>estamos optando por obtener s\u00f3lo el id<\/code> y nombre<\/code> de nuestros resultados. Para ejecutar realmente la consulta, emitiremos una sentencia cURL como \u00e9sta:<\/p>\n
curl -g 'https:\/\/localhost:8080\/graphql?query={accounts{id,firstname}}'<\/pre>\n
Recuerde, nuestra consulta GraphQL se env\u00eda ver los par\u00e1metros de consulta a nuestro punto final de la API.<\/p>\n
Veamos otra posible consulta GraphQL. Digamos que queremos consultar una cuenta en particular, no todas las cuentas. Podr\u00edamos crear un campo como el siguiente:<\/p>\n
\"account\": &graphql.Field{\r\n    Type: accountType,\r\n    Args: graphql.FieldConfigArgument{\r\n        \"id\": &graphql.ArgumentConfig{\r\n            Type: graphql.NewNonNull(graphql.String),\r\n        },\r\n    },\r\n    Resolve: func(params graphql.ResolveParams) (interface{}, error) {\r\n        var account Account\r\n        account.ID = params.Args[\"id\"].(string)\r\n        _, err := bucket.Get(account.ID, &account)\r\n        if err != nil {\r\n            return nil, err\r\n        }\r\n        return account, nil\r\n    },\r\n},<\/pre>\n
Si se consulta este campo, se obtendr\u00e1 un \u00fanico accountType<\/code>pero hay argumentos que se pueden pasar. Requerimos que un id<\/code> y exigimos que sea una cadena. En el Resolver<\/code>podemos obtener el id<\/code> y utilizarlo para obtener un documento NoSQL por la clave del documento. El resultado se devuelve y la consulta GraphQL determina qu\u00e9 propiedades se devuelven al cliente.<\/p>\n
Tome la siguiente consulta:<\/p>\n
{\r\n    account(id:\"2345345435\") {\r\n        firstname,\r\n        lastname\r\n    }\r\n}<\/pre>\n
En la consulta anterior, pasamos un ID y elegimos devolver s\u00f3lo el nombre<\/code> y apellido<\/code> de los resultados. Para ejecutar realmente esta consulta, podemos emitir una sentencia cURL como la siguiente:<\/p>\n
curl -g 'https:\/\/localhost:8080\/graphql?query={account(id:\"2345345435\"){firstname,lastname}}'<\/pre>\n
Supongamos ahora que queremos obtener todos los blogs de una cuenta de usuario determinada. Los pasos ser\u00e1n similares a los que vimos al consultar una cuenta concreta. Lo siguiente existir\u00eda como un campo en nuestro rootQuery<\/code>:<\/p>\n
\"blogs\": &graphql.Field{\r\n    Type: graphql.NewList(blogType),\r\n    Args: graphql.FieldConfigArgument{\r\n        \"account\": &graphql.ArgumentConfig{\r\n            Type: graphql.NewNonNull(graphql.String),\r\n        },\r\n    },\r\n    Resolve: func(params graphql.ResolveParams) (interface{}, error) {\r\n        account := params.Args[\"account\"].(string)\r\n        query := gocb.NewN1qlQuery(\"SELECT META(blog).id, blog.* FROM example AS blog WHERE blog.type = 'blog' AND blog.account = $1\")\r\n        var n1qlParams []interface{}\r\n        n1qlParams = append(n1qlParams, account)\r\n        rows, err := bucket.ExecuteN1qlQuery(query, n1qlParams)\r\n        if err != nil {\r\n            return nil, err\r\n        }\r\n        var blogs []Blog\r\n        var row Blog\r\n        for rows.Next(&row) {\r\n            blogs = append(blogs, row)\r\n        }\r\n        return blogs, nil\r\n    },\r\n},<\/pre>\n
El resultado ser\u00e1 una lista de blogTipo<\/code> y esperamos un cuenta<\/code> en formato de cadena. Dentro del campo Resolver<\/code> podemos obtener la funci\u00f3n cuenta<\/code> y utilizarlo en una consulta N1QL parametrizada. La consulta devolver\u00e1 todas las entradas del blog s\u00f3lo para una cuenta en particular basada en el valor cuenta<\/code> valor.<\/p>\n
La consulta para obtener todos los blogs podr\u00eda tener el siguiente aspecto:<\/p>\n
{\r\n    blogs(account:\"2345345435\") {\r\n        id,\r\n        title\r\n    }\r\n}<\/pre>\n
Lo anterior se parece bastante a lo que vimos al consultar una cuenta concreta. Estamos esperando una variable y estamos optando por devolver \u00fanicamente la variable id<\/code> y el t\u00edtulo<\/code> propiedades.<\/p>\n
\u00bfQuieres ver una consulta bastante interesante basada en lo que tenemos hasta ahora? Echa un vistazo a la siguiente consulta:<\/p>\n
{\r\n    account(id:\"2345345435\") {\r\n        firstname,\r\n        lastname\r\n    }\r\n    blogs(account:\"2345345435\") {\r\n        title,\r\n        content\r\n    }\r\n}<\/pre>\n
En el ejemplo anterior estamos haciendo una \u00fanica petici\u00f3n. Es una \u00fanica consulta, pero estamos pidiendo los datos de la cuenta y los datos del blog de una cuenta en particular. Si lo hubi\u00e9ramos hecho con una API RESTful habr\u00edamos realizado varias peticiones a nuestro servidor y habr\u00edamos hecho posibles mutaciones a nivel de aplicaci\u00f3n.<\/p>\n
El comando cURL tendr\u00eda el siguiente aspecto:<\/p>\n
curl -g 'https:\/\/localhost:8080\/graphql?query={account(id:\"2345345435\"){firstname,lastname}blogs(account:\"2345345435\"){title,content}}'<\/pre>\n
Hasta ahora s\u00f3lo hemos hecho consultas de lectura. \u00bfY si quisi\u00e9ramos hacer una mutaci\u00f3n en la que creamos o alteramos datos?<\/p>\n
Echemos un vistazo a las mutaciones de datos con GraphQL.<\/p>\n
En lugar de trabajar en el rootQuery<\/code>vamos a trabajar en el rootMutation<\/code>. Para los campos, a\u00f1ada lo siguiente:<\/p>\n
\"createAccount\": &graphql.Field{\r\n    Type: accountType,\r\n    Args: graphql.FieldConfigArgument{\r\n        \"firstname\": &graphql.ArgumentConfig{\r\n            Type: graphql.NewNonNull(graphql.String),\r\n        },\r\n        \"lastname\": &graphql.ArgumentConfig{\r\n            Type: graphql.NewNonNull(graphql.String),\r\n        },\r\n    },\r\n    Resolve: func(params graphql.ResolveParams) (interface{}, error) {\r\n        var account Account\r\n        account.Firstname = params.Args[\"firstname\"].(string)\r\n        account.Lastname = params.Args[\"lastname\"].(string)\r\n        account.Type = \"account\"\r\n        id, _ := uuid.NewV4()\r\n        _, err := bucket.Insert(id.String(), &account, 0)\r\n        if err != nil {\r\n            return nil, err\r\n        }\r\n        account.ID = id.String()\r\n        return account, nil\r\n    },\r\n},<\/pre>\n
Observe que devolvemos un accountType<\/code> y que esperamos que se pasen dos par\u00e1metros con nuestra consulta. Sin embargo, la estrategia en realidad no es diferente.<\/p>\n
En el Resolver<\/code> estamos obteniendo nuestros par\u00e1metros y us\u00e1ndolos para crear una nueva cuenta en la base de datos. Debido a que esto est\u00e1 vinculado a nuestro esquema como una mutaci\u00f3n, estamos consultando de manera diferente.<\/p>\n
En primer lugar, he aqu\u00ed la consulta que querr\u00edamos ejecutar:<\/p>\n
mutation+_ {\r\n    createAccount(firstname:\"Matt\",lastname:\"Groves\") {\r\n        id,\r\n        firstname,\r\n        lastname\r\n    }\r\n}<\/pre>\n
F\u00edjate en que estamos prefijando con la palabra mutaci\u00f3n<\/code>. En cURL, tendr\u00eda el siguiente aspecto:<\/p>\n
curl -g 'https:\/\/localhost:8080\/graphql?query=mutation+_{createAccount(firstname:\"Matt\",lastname:\"Groves\"){id,firstname,lastname}}'<\/pre>\n
Ahora podr\u00eda seguir creando campos que hagan consultas o mutaciones, pero los pasos son los mismos. Dejar\u00e9 a tu imaginaci\u00f3n que siga contribuyendo a esta idea de aplicaci\u00f3n en particular.<\/p>\n
Conclusi\u00f3n<\/h2>\n
Acaba de ver c\u00f3mo utilizar GraphQL<\/a> para consultar datos en una aplicaci\u00f3n Golang que utiliza un archivo Base de datos NoSQL<\/a>. GraphQL es muy \u00fatil si quieres dejar que el usuario defina qu\u00e9 datos quiere en una sola solicitud en lugar de crear incansablemente m\u00faltiples puntos finales de API RESTful que el usuario debe seguir. Es importante tener en cuenta que GraphQL no es un sustituto cuando se trata de que tu aplicaci\u00f3n consulte tu base de datos. Usted todav\u00eda tendr\u00e1 que crear consultas N1QL adecuadas en Couchbase<\/a>. GraphQL s\u00f3lo opera a nivel de cliente.<\/p>\n
Para obtener m\u00e1s informaci\u00f3n sobre el uso de Go con Couchbase, consulte la p\u00e1gina Portal para desarrolladores de Couchbase<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
A few weeks ago I had mentioned that I was learning about the increasingly popular GraphQL and how it can be a replacement to the common RESTful API. In my previous example, we saw how to create a GraphQL application […]<\/p>","protected":false},"author":63,"featured_media":13873,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1814,1815,1816,1820,1812],"tags":[2210,1725],"ppma_author":[9032],"class_list":["post-5089","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-application-design","category-best-practices-and-tutorials","category-couchbase-server","category-golang","category-n1ql-query","tag-graphql","tag-nosql-database"],"acf":[],"yoast_head":"\nUsing GraphQL with Golang and a NoSQL Database<\/title>\n<meta name=\"description\" content=\"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.couchbase.com\/blog\/es\/using-graphql-with-golang-and-a-nosql-database\/\" \/>\n<meta property=\"og:locale\" content=\"es_MX\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Using GraphQL with Golang and a NoSQL Database\" \/>\n<meta property=\"og:description\" content=\"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.couchbase.com\/blog\/es\/using-graphql-with-golang-and-a-nosql-database\/\" \/>\n<meta property=\"og:site_name\" content=\"The Couchbase Blog\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/thepolyglotdeveloper\" \/>\n<meta property=\"article:published_time\" content=\"2018-05-08T16:00:31+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-06-14T01:45:29+00:00\" \/>\n<meta name=\"author\" content=\"Nic Raboy, Developer Advocate, Couchbase\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@nraboy\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Nic Raboy, Developer Advocate, Couchbase\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/\"},\"author\":{\"name\":\"Nic Raboy, Developer Advocate, Couchbase\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1\"},\"headline\":\"Using GraphQL with Golang and a NoSQL Database\",\"datePublished\":\"2018-05-08T16:00:31+00:00\",\"dateModified\":\"2025-06-14T01:45:29+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/\"},\"wordCount\":1481,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png\",\"keywords\":[\"graphql\",\"NoSQL Database\"],\"articleSection\":[\"Application Design\",\"Best Practices and Tutorials\",\"Couchbase Server\",\"GoLang\",\"SQL++ \/ N1QL Query\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/\",\"name\":\"Using GraphQL with Golang and a NoSQL Database\",\"isPartOf\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png\",\"datePublished\":\"2018-05-08T16:00:31+00:00\",\"dateModified\":\"2025-06-14T01:45:29+00:00\",\"description\":\"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png\",\"width\":1800,\"height\":630},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.couchbase.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Using GraphQL with Golang and a NoSQL Database\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#website\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"name\":\"The Couchbase Blog\",\"description\":\"Couchbase, the NoSQL Database\",\"publisher\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#organization\",\"name\":\"The Couchbase Blog\",\"url\":\"https:\/\/www.couchbase.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"contentUrl\":\"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png\",\"width\":218,\"height\":34,\"caption\":\"The Couchbase Blog\"},\"image\":{\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1\",\"name\":\"Nic Raboy, Developer Advocate, Couchbase\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/8863514d8bed0cf6080f23db40e00354\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g\",\"caption\":\"Nic Raboy, Developer Advocate, Couchbase\"},\"description\":\"Nic Raboy is an advocate of modern web and mobile development technologies. He has experience in Java, JavaScript, Golang and a variety of frameworks such as Angular, NativeScript, and Apache Cordova. Nic writes about his development experiences related to making web and mobile development easier to understand.\",\"sameAs\":[\"https:\/\/www.thepolyglotdeveloper.com\",\"https:\/\/www.facebook.com\/thepolyglotdeveloper\",\"https:\/\/x.com\/nraboy\"],\"url\":\"https:\/\/www.couchbase.com\/blog\/es\/author\/nic-raboy-2\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Uso de GraphQL con Golang y una base de datos NoSQL","description":"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.couchbase.com\/blog\/es\/using-graphql-with-golang-and-a-nosql-database\/","og_locale":"es_MX","og_type":"article","og_title":"Using GraphQL with Golang and a NoSQL Database","og_description":"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.","og_url":"https:\/\/www.couchbase.com\/blog\/es\/using-graphql-with-golang-and-a-nosql-database\/","og_site_name":"The Couchbase Blog","article_author":"https:\/\/www.facebook.com\/thepolyglotdeveloper","article_published_time":"2018-05-08T16:00:31+00:00","article_modified_time":"2025-06-14T01:45:29+00:00","author":"Nic Raboy, Developer Advocate, Couchbase","twitter_card":"summary_large_image","twitter_creator":"@nraboy","twitter_misc":{"Written by":"Nic Raboy, Developer Advocate, Couchbase","Est. reading time":"9 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#article","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/"},"author":{"name":"Nic Raboy, Developer Advocate, Couchbase","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1"},"headline":"Using GraphQL with Golang and a NoSQL Database","datePublished":"2018-05-08T16:00:31+00:00","dateModified":"2025-06-14T01:45:29+00:00","mainEntityOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/"},"wordCount":1481,"commentCount":0,"publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png","keywords":["graphql","NoSQL Database"],"articleSection":["Application Design","Best Practices and Tutorials","Couchbase Server","GoLang","SQL++ \/ N1QL Query"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/","url":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/","name":"Uso de GraphQL con Golang y una base de datos NoSQL","isPartOf":{"@id":"https:\/\/www.couchbase.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage"},"thumbnailUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png","datePublished":"2018-05-08T16:00:31+00:00","dateModified":"2025-06-14T01:45:29+00:00","description":"Learn how to create a web application using the Go programming language and a Couchbase NoSQL database that can be queried using GraphQL from the front-end.","breadcrumb":{"@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#primaryimage","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/sites\/1\/2022\/11\/couchbase-nosql-dbaas.png","width":1800,"height":630},{"@type":"BreadcrumbList","@id":"https:\/\/www.couchbase.com\/blog\/using-graphql-with-golang-and-a-nosql-database\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.couchbase.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Using GraphQL with Golang and a NoSQL Database"}]},{"@type":"WebSite","@id":"https:\/\/www.couchbase.com\/blog\/#website","url":"https:\/\/www.couchbase.com\/blog\/","name":"El blog de Couchbase","description":"Couchbase, la base de datos NoSQL","publisher":{"@id":"https:\/\/www.couchbase.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.couchbase.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Organization","@id":"https:\/\/www.couchbase.com\/blog\/#organization","name":"El blog de Couchbase","url":"https:\/\/www.couchbase.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","contentUrl":"https:\/\/www.couchbase.com\/blog\/wp-content\/uploads\/2023\/04\/admin-logo.png","width":218,"height":34,"caption":"The Couchbase Blog"},"image":{"@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/bb545ebe83bb2d12f91095811d0a72e1","name":"Nic Raboy, Defensor del Desarrollador, Couchbase","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.couchbase.com\/blog\/#\/schema\/person\/image\/8863514d8bed0cf6080f23db40e00354","url":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","caption":"Nic Raboy, Developer Advocate, Couchbase"},"description":"Nic Raboy es un defensor de las tecnolog\u00edas modernas de desarrollo web y m\u00f3vil. Tiene experiencia en Java, JavaScript, Golang y una variedad de frameworks como Angular, NativeScript y Apache Cordova. Nic escribe sobre sus experiencias de desarrollo relacionadas con hacer el desarrollo web y m\u00f3vil m\u00e1s f\u00e1cil de entender.","sameAs":["https:\/\/www.thepolyglotdeveloper.com","https:\/\/www.facebook.com\/thepolyglotdeveloper","https:\/\/x.com\/nraboy"],"url":"https:\/\/www.couchbase.com\/blog\/es\/author\/nic-raboy-2\/"}]}},"authors":[{"term_id":9032,"user_id":63,"is_guest":0,"slug":"nic-raboy-2","display_name":"Nic Raboy, Developer Advocate, Couchbase","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/bedeb68368d4681aca4c74fe5f697f0c423b80d498ec50fd915ba018b72c101f?s=96&d=mm&r=g","first_name":"Nic","last_name":"Raboy","user_url":"https:\/\/www.thepolyglotdeveloper.com","author_category":"","description":"Nic Raboy es un defensor de las tecnolog\u00edas modernas de desarrollo web y m\u00f3vil. Tiene experiencia en Java, JavaScript, Golang y una variedad de frameworks como Angular, NativeScript y Apache Cordova. Nic escribe sobre sus experiencias de desarrollo relacionadas con hacer el desarrollo web y m\u00f3vil m\u00e1s f\u00e1cil de entender."}],"_links":{"self":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts\/5089","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/users\/63"}],"replies":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/comments?post=5089"}],"version-history":[{"count":0,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/posts\/5089\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/media\/13873"}],"wp:attachment":[{"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/media?parent=5089"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/categories?post=5089"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/tags?post=5089"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.couchbase.com\/blog\/es\/wp-json\/wp\/v2\/ppma_author?post=5089"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}