April 2017 Summaries

Couchbase Server 4.0 introduced Global Secondary Indexes (GSI) to support the N1QL query engine, but managing these indexes was manual and required high availability configuration, node addition or removal, and index rebalancing after failures. With Couchbase Server 5.0, automatic replication and rebalancing of GSIs are now built-in, allowing users to specify the number of replicas and automatically manage their placement across nodes, server groups, and availability zones. This enables better index availability and manageability, and supports rebalancing without downtime. Users can also adjust the number of replicas after index creation using an upcoming ALTER INDEX statement.

Tony Branson, a tech enthusiast, explores the evolving landscape of database technologies, focusing on the choice between SQL and NoSQL systems. SQL databases are ideal for applications requiring ACID compliance and handling structured data, while NoSQL systems offer flexibility and scalability, particularly for unstructured data and real-time processing needs. The text emphasizes that no single solution fits all scenarios, urging businesses to consider their specific data requirements and growth projections when making a choice. It suggests that a combination of both SQL and NoSQL may provide the best results, especially when supported by database load balancing software that enhances performance and reliability during high traffic. The discussion also highlights the importance of understanding ACID compliance and the benefits of document-style data modeling offered by NoSQL platforms like Couchbase.

The text provides a detailed guide on developing a mobile application using NativeScript and Angular to capture images and store them in Couchbase Lite, a device-level NoSQL database, as base64 encoded strings. It outlines the necessary tools and steps for creating a NativeScript project, setting up the Couchbase plugin, and managing permissions for iOS. The guide walks through the process of stripping unnecessary code from boilerplate files, implementing core application logic in TypeScript, and designing a simple UI to display captured images. The application uses the device's camera to capture images, converts them to base64, and saves them to the database, with the HTML interface featuring an action bar for triggering the camera and displaying images. The text concludes with a mention of future plans to sync the image data across devices and invites readers to explore further resources on using NativeScript with Couchbase. Additionally, it addresses a troubleshooting query regarding image processing and offers a minor correction for users of NativeScript 3.0.

The post explores the process of implementing data replication and synchronization across iOS devices using Couchbase Mobile, which includes Couchbase Server, Sync Gateway, and Couchbase Lite. It guides users through setting up a sample iOS app to demonstrate core concepts such as push and pull replication, authentication, access control, channels, and sync functions, while noting that the principles apply to other mobile platforms like Android and Xamarin. Detailed instructions for installing and configuring the Sync Gateway are provided, including a discussion on the use of JavaScript sync functions for document validation and access control. The post also covers the integration of Couchbase Lite into iOS apps through the native API, emphasizing its role in replicating data between local databases and the Sync Gateway. The demo app example illustrates how to handle user authentication and manage document synchronization, including setting up continuous replication and monitoring its status. The post concludes by inviting feedback and highlighting upcoming features in Couchbase Mobile 2.0.

Couchbase Server 5.0 introduces enhanced security features through Role-Based Access Control (RBAC), replacing the previous bucket password system with user-specific roles that offer varying levels of access. This update allows for more granular control over data access by creating users with specific permissions, improving security and reducing exposure. Users can be created via the Couchbase Web Console or the REST API, and roles can be managed with N1QL commands. The system supports a wide range of permissions, including query, data reading, and administrative tasks, allowing for tailored user roles across different buckets. Feedback on these new features is encouraged as the full release approaches, with the Couchbase team actively seeking input from users to refine the system.

Joel Andrews, a versatile developer based in Canada's west coast, elaborates on using synctos, an open-source tool developed by Kashoo to streamline the creation of sync functions for Couchbase Sync Gateway. In his post, Andrews introduces the tool's built-in test-helper module, which aids in writing tests that validate document definitions, underscoring the importance of testing code for bugs. He provides a detailed walkthrough on setting up a Node.js project with necessary dependencies like expect.js, mocha, and simple-mock, and explains the process of creating a simple document definition as a demonstration. Andrews guides readers through generating a sync function using synctos, setting up test cases to validate document constraints, and running tests to ensure accuracy. He encourages exploring the test-helper module's documentation for advanced testing capabilities and directs readers to GitHub for source code access.

Urban Airship is a messaging and notification service that can be used in conjunction with Couchbase Mobile to trigger data synchronizations on mobile devices. The setup process involves integrating Urban Airship with an Android or iOS project through a series of steps that include modifying gradle scripts, creating an Application class, and configuring Firebase Cloud Messaging. The guide details how to use Urban Airship to send push notifications that trigger unidirectional data replications in Couchbase Mobile, using a Sync Gateway as the cloud component. This approach helps to manage battery consumption by reducing the need for continuous network connections and takes advantage of Urban Airship's advanced features for targeting specific devices. The example provided demonstrates the integration through implementing classes like Autopilot and AirshipReceiver, setting up a main activity to display document changes, and using a database helper class to manage Couchbase Lite functionality. The tutorial also covers testing the setup using an Android emulator and Sync Gateway, and provides guidance on posting push notifications via Urban Airship's API to initiate database replications or reset the database.

Ratnopam Chakrabarti, a software developer at Ericsson Inc., offers insights into using Docker Compose for orchestrating multi-container environments, specifically for deploying a Spring Boot web application powered by Couchbase. In the second part of his series, Chakrabarti demonstrates how to streamline the deployment process by using Docker Compose to automate the launch of a Couchbase container followed by an application container, thus overcoming the limitations of manually running separate commands for each container. He provides a detailed guide, including a sample `docker-compose.yml` file and a Dockerfile, highlighting the use of a script to ensure that the Couchbase container is fully configured before starting the application. This approach enhances the deployment process by enabling a single orchestration command to bring up the entire application stack. Additionally, Chakrabarti notes the potential for using Docker Compose to automate testing environments, emphasizing its flexibility and utility in managing complex container setups.

I am pleased to announce that the latest episode of The NoSQL Database Podcast has been published, featuring a discussion about Marten and its role in .NET development. Jeremy Miller, the author of Marten, joins me on the show to explain how it works and its benefits for developers. The episode is now available on popular podcasting networks such as iTunes and Pocket Casts, and can also be listened to directly from this website. If you're interested in learning more about Marten or have questions, check out the official website or Twitter for updates. Additionally, if you're looking for a NoSQL solution to use with .NET, consider checking out the Couchbase Developer Portal.

The text provides a detailed guide on setting up a continuous deployment pipeline using Jenkins and Node.js, focusing on automating the process based on changes made to a GitHub repository. The tutorial uses an existing React JS repository from the "React From Scratch" workshop to demonstrate how Jenkins can build and deploy the application. It outlines the software requirements, such as installing Node.js and Java, and guides users through configuring Jenkins, including the installation of necessary plugins like PostBuildScript. The process involves creating a Jenkins Freestyle Project, pulling the project from GitHub, building it by installing dependencies via `npm install`, and deploying it locally with `npm start`. While the example is configured for a local setup, it suggests that in a production environment, additional steps such as using SSH for deployment might be necessary. The text concludes by highlighting the usefulness of Jenkins for Node.js applications and suggests additional resources for those interested in similar Java processes or integrating Node.js with Couchbase NoSQL.

The guide offers a comprehensive tutorial on creating and deploying custom Docker images for a Java RESTful API using Spring Boot and Couchbase Server. It begins with the development of a custom Couchbase Docker image that includes a provisioning script to automatically configure resources and credentials upon deployment. The tutorial then shifts to building a Spring Boot application, explaining how to set up project properties, endpoints, and dependencies using Gradle. A Dockerfile is created to package the Java application into a Docker image, which is then deployed alongside the Couchbase image using Docker Compose. This approach allows the two applications to communicate effectively, providing a convenient solution for maintaining web applications. The guide also references previous articles for those interested in similar implementations with Node.js and offers resources for learning more about the Couchbase Java SDK.

Couchbase has released the Developer Preview 2 of Couchbase Analytics, a tool aimed at facilitating data analysis without the need for rigid schemas or expensive data transformations. It features SQL++, a versatile query language that extends SQL for use with modern NoSQL systems, and supports the same flexible-schema document model as Couchbase Server. The tool offers workload isolation by running analytical queries on dedicated nodes, ensuring minimal impact on operational workloads, and provides high data freshness through a fast synchronization protocol. The latest preview focuses on enhancing ease of use, introducing features like configurable parallelism, query cancellation, and simplified cluster installation, while SDK support has been expanded to include Java, .NET, node.js, php, and python. Users can enable analytics support in the Java SDK by setting a system property and are encouraged to explore the tool through available tutorials and the upcoming Couchbase Connect NYC event.

Swagger is an ecosystem of tools and resources for managing REST APIs, which has been incorporated into Couchbase's documentation a few months ago. The Swagger specification is the core component, and once the API spec is defined for endpoints, it provides valuable capabilities such as live embeddable documentation and client libraries. These features can be demonstrated through various videos and blog posts, including an example of using a Swagger JavaScript client with Couchbase Mobile. The public and admin APIs for Sync Gateway have also been made available, along with configuration files that can be used to test the API endpoints, although there is currently a known issue with making calls from the Couchbase documentation due to security requirements.

The post provides a detailed guide on using the Postman Chrome Developer tool to interact with the Couchbase Mobile Sync Gateway's REST API, specifically focusing on Couchbase Mobile v1.4. It outlines the process of setting up the Sync Gateway, which syncs data across devices and the cloud via Admin and Public ports, and demonstrates how to download and use Postman collections and environment definitions from a GitHub repository. The guide emphasizes the importance of configuring Postman to work with the appropriate environment settings, allowing users to query and test the REST interface effectively. Additionally, it introduces Newman, a command-line interface tool for running Postman collections, which can be useful for integrating API tests into continuous integration processes. The post encourages user contributions to the GitHub repository for enhancements and provides contact information for further queries or support.

Couchbase has announced the general availability of Couchbase Community Edition 4.5.1, which enhances the previous 4.5 series with significant bug fixes to improve stability. This version is aimed at developers in the community to familiarize themselves with Couchbase's offerings. For users managing business-critical applications in production environments, Couchbase recommends considering its Enterprise Edition, which offers additional features and support.

Ratnopam Chakrabarti, a software developer working for Ericsson Inc., has shared an in-depth guide on running a Couchbase-powered Spring Boot web application using the Docker toolset. The tutorial is divided into two parts and covers setting up a Couchbase environment, building and configuring the application, and deploying it as a standalone Docker container. By following this guide, developers can create a fully functional CRUD (Create, Read, Update, Delete) application that leverages the benefits of Spring Boot and Vaadin for its user interface.

The blog post discusses the transition from SQL to JSON data modeling, highlighting the use of Hackolade, a tool that now supports Couchbase and assists in this process. The post reviews a manual modeling exercise involving shopping carts and social media users, illustrating how relationships in a relational database, typically represented via key/foreign key, can be translated into JSON through techniques like referential and denormalization. Hackolade aids in automating and visualizing this conversion, offering features such as reverse engineering from SQL server DDL files to JSON models, suggesting denormalization strategies, and allowing users to refine models by embedding arrays or sub-documents. The post emphasizes Hackolade's capabilities in generating dynamic models that can be shared and documented, enhancing the development and architecture of applications transitioning to NoSQL databases like Couchbase.

The text provides a detailed guide on using Jenkins to set up a continuous deployment pipeline for a Java application that communicates with Couchbase Server. The process involves configuring Jenkins on a local machine alongside JDK and Couchbase, pulling code from a GitHub repository, building a Java JAR file, and deploying it locally using Jenkins. The author highlights the necessity of certain plugins and dependencies, such as the Post-Build Script plugin, to execute scripts after a successful build. Although the setup is simplified for demonstration purposes by running everything on a local machine, including killing and restarting processes, it serves as an introductory approach to continuous deployment with Jenkins. The guide concludes with suggestions for further exploration, including deploying Docker containers with Jenkins and additional resources on Java continuous deployment with Couchbase.

The April 2017 Developer Build for Couchbase Server 5.0 introduces numerous bug fixes and feature enhancements, bringing the release closer to its stable version. Key updates include enhancements to Role-Based Access Control (RBAC), improvements in N1QL query performance, and the introduction of Global Secondary Index (GSI) replicas and rebalancing capabilities. The build is also compatible with new platforms such as Oracle Linux 7, Ubuntu 16.04, and Windows Server 2016, while support for Ubuntu 12 is being phased out. The update addresses critical and major bugs affecting various features like ephemeral buckets, Full-Text Search (FTS), and N1QL operations, among others. Developers are encouraged to download the build and provide feedback through Couchbase's web console, forums, or directly via email or Twitter, helping to refine the software before its final release.

You can perform bulk operations on multiple documents without an index by using the `USE KEYS` operator with a list of document IDs. This allows you to query specific documents based on their keys, even if there is no primary or secondary index created. The `USE KEYS` operator enables you to narrow down your query results to only those documents that match the specified keys, providing fast performance similar to how it would be achieved with indexes. By utilizing this operator, you can write N1QL queries on Couchbase Buckets without relying on indexes, making it possible to perform efficient key-based operations.

The post provides a comprehensive guide to integrating Couchbase Lite, an embedded JSON database, into iOS applications using Swift, though the principles apply to other platforms like Android and Xamarin. It focuses on using Couchbase Lite as a standalone database, highlighting its compatibility with a remote Sync Gateway for data synchronization and its ability to function in a peer-to-peer network. The guide covers essential steps such as creating a local database, adding, listing, editing, and deleting documents, and observing changes in the database. Integration can be streamlined using dependency management systems like Cocoapods or Carthage, and a demo Xcode project is available on GitHub for practical exploration. The post emphasizes the simplicity of integrating Couchbase Lite into iOS apps, providing resources for further learning and community support through the Couchbase Developer Portal and forums.

The text draws a parallel between the experience of attending a Human League concert and the evolution of Couchbase's software products, highlighting the tension between new offerings and the foundational features that initially garnered attention. The author reflects on the excitement of hearing classic hits at the concert, likening it to customer expectations for Couchbase's original high-performance key-value store. Couchbase has evolved significantly since its inception, with versions introducing features like N1QL, mobile solutions, and role-based access control, while maintaining a focus on performance. As they prepare for the release of Couchbase 5.0, the company balances innovation with the core attributes of scalability, availability, and speed, ensuring they meet both new and loyal customer demands. The narrative underscores a commitment to enhancing performance without sacrificing the foundational qualities that established their reputation.

Aaron Benton, an experienced architect and Applications Architect for Shop.com, discusses the advanced capabilities of the FakeIt tool in working with existing data, focusing on its integration with legacy systems and existing datasets. He highlights how developers often face the challenge of working with non-greenfield applications, which involve complex legacy databases. FakeIt facilitates using existing data by accepting inputs in formats like JSON, CSV, or CSON, which can be utilized within model functions to maintain consistency and integrity when building new applications. The text provides practical insights through examples, such as updating a user model to support specific countries and a product model to integrate valid category information from a CSV file. This approach ensures efficient data handling and model consistency, emphasizing the power of FakeIt in generating coherent data models aligned with existing systems, potentially transforming and importing data into environments like Couchbase Server.

This tutorial guides developers through importing MongoDB collection data into Couchbase using Golang. It begins by discussing how to export MongoDB collections as JSON files and then explains how to modify the structure of these documents for use in a Couchbase bucket. The author provides sample code for a Go program that reads from a JSON file, manipulates each document, and inserts it into a Couchbase bucket using goroutines for parallel processing. Finally, the tutorial outlines steps for running the MongoDB to Couchbase importer and suggests optimizing the code further based on individual needs.

Couchbase hosts regular meetups in its Mountain View office, providing a platform for developers to learn about the latest technology trends and get hands-on experience with various tools and frameworks. The February 2nd, 2017 meetup featured Nic Raboy's demonstration of building an application using Node.js, Angular, and Couchbase, which is available on YouTube and GitHub. Additionally, attendees can download Couchbase directly from its website, access developer resources through the portal, and engage with the community on Twitter, forums, and Stack Overflow. The meetup is designed to facilitate knowledge sharing and collaboration among developers, helping them build scalable and efficient applications.

C# tuples are a new feature of C# 7 that allow creating anonymous types with richer information. They are similar to anonymous objects but provide more type safety and flexibility, making it easier to return and pass data as a single unit. The syntax for tuples is to put parentheses around a comma-separated list of types and names, allowing for easy creation of classes on the fly without defining them explicitly. Tuples can be used in methods as both return types and parameter types, providing a convenient way to handle complex data structures. The author demonstrates their use with a simple console app that interacts with Couchbase, showcasing how tuples can be used to get and insert documents into a database.

A document-oriented database, such as Couchbase, differs from a relational database in its concept and structure, with a flexible schema that allows for dynamic changes. In contrast to relational databases, which rely on SQL commands and rigid schemas, document-oriented databases store data in JSON documents without a structured query language. A document-oriented database like Couchbase offers advantages over relational databases in handling big data, providing scale-out performance over a cluster of nodes, and addressing eventual consistency through advanced replication features. The document-oriented database can be queried using N1QL, a specific query language that allows running SQL against JSON documents, making it an interesting alternative to relational databases. By creating buckets, managing data storage and retrieval in documents, and querying documents using N1QL clauses such as SELECT, FROM, and WHERE, developers can effectively work with document-oriented databases like Couchbase.

Docker's rising popularity is attributed to its ability to provide a consistent deployment environment for applications, and this text explores using Docker to containerize a Node.js web application integrated with Couchbase, a NoSQL database. Node.js, an open-source, cross-platform JavaScript runtime, is paired with Couchbase to build a custom container, emphasizing the need for a configuration script to provision the Couchbase server effectively. The guide walks through creating Dockerfiles and configuration scripts for a custom Couchbase image, detailing how to set up environment variables to avoid hardcoding sensitive information. It further explains how to develop a simple Node.js RESTful API, which communicates with Couchbase through defined endpoints, and how to containerize this application using Docker. A Docker Compose file is introduced to simplify deployment by managing environment variables and ensuring both Node.js and Couchbase containers run seamlessly on the same network, although care is advised to ensure Couchbase is ready before starting the Node.js application. This comprehensive approach to containerization underscores Docker’s utility in deploying web applications reliably across different environments.

At the Indy.Code() conference in Indianapolis, a workshop was delivered on ASP.NET with NoSQL, specifically focusing on Couchbase Server. The workshop was divided into four parts, including installing Couchbase Server, interacting with it via the Web Console and .NET SDK, creating a RESTful API using ASP.NET WebAPI, and consuming the API with an Angular frontend. For those who could not attend, the workshop materials, including PowerPoint and PDF files, are available on GitHub, alongside completed versions of each section. Participants are encouraged to seek assistance through the Couchbase .NET Forums and the Couchbase Developer Portal for further information, with additional support available via Twitter contact.