March 2016 Summaries

The text contrasts relational databases with NoSQL databases, specifically focusing on Couchbase, highlighting both similarities and differences in their structures and functionalities. In relational databases, data is organized into tables with rows and columns, while Couchbase uses a flexible document-based approach with JSON documents, allowing for a dynamic schema that can be easily modified. The document explains that Couchbase's Sub Document API enables operations on individual JSON fields, similar to manipulating specific columns in relational databases. Couchbase employs a query language called N1QL, a SQL superset, which allows for operations like JOINs using Buckets instead of tables. The text also discusses the differences in security approaches, noting that Couchbase manages permissions at the Bucket level, requiring some security logic to be handled at the application level, a shift from the column-level security of relational databases. The author concludes by inviting discussion on the implications of these differences, particularly regarding the location of application logic.

This blog post provides an introduction to using Cloud9 Charts with Couchbase, leveraging N1QL's query capabilities. The integration allows for visual insights and business intelligence reporting directly from Couchbase data, without the need for separate tools or servers. Key features include native N1QL support, drag-and-drop analysis, and multi-datasource joins. A walkthrough demonstrates how to use N1QL to analyze a sample dataset and build a simple dashboard with visualizations. The integration enables users to easily gain insights from Couchbase data without modifying the underlying NoSQL structure.

The third episode of The NoSQL Database Podcast, sponsored by Couchbase, features a discussion with Tom Coates, Senior Principal Architect at Nuance, about the company's transition from Oracle to NoSQL databases. Coates shares the challenges and considerations Nuance faced while exploring two different NoSQL solutions before settling on the best fit for their needs, offering insights on the types of data stored in Oracle and the factors driving their decision to transition. The episode, accessible on Pocket Casts and iTunes, aims to provide listeners with valuable insights and reassurances for those contemplating a similar switch. Listeners are encouraged to submit questions to the podcast for further discussion.

The text outlines a simple Spring Boot application designed to utilize Couchbase's search features for managing file uploads, storage, and retrieval. It discusses the limitations of storing files directly in databases, advocating for the use of binary stores for file storage, while associated metadata is stored in the database. The project involves a basic implementation where uploaded files are stored in a designated filesystem folder with SHA-1 digests as filenames, and metadata and text extraction are performed using tools like ExifTool and Poppler. The application supports searching files by metadata or content using N1QL and Full Text Search (FTS) queries, facilitated by a Search Service. Configuration details, including binary store paths and Couchbase server addresses, are briefly covered, and the application incorporates a user interface built with Thymeleaf and Semantic UI. The document concludes with suggestions for potential enhancements, such as advanced search forms and multiple file uploads.

Apache Spark is an efficient tool for processing massive amounts of data, performing significantly better than MapReduce. It works well in combination with Couchbase through the Couchbase Spark Connector. To load CSV data into Couchbase using Apache Spark, one needs to include Spark Core, Spark SQL, Spark CSV, and the Couchbase Spark Connector as dependencies. The raw data is loaded into an Apache Spark DataFrame, which can be queried using Spark SQL. The DataFrame is then prepared for saving to Couchbase by mapping the id value to a document id. Finally, the project can be executed using Maven and the `spark-submit` command, which may take some time depending on the size of the dataset and the speed of the computer or server.

For many years, databases have benefited from a caching tier due to its ability to reduce latency during high throughput by caching reads, writes, and frequently executed query results. Caching tiers are essential to prevent overloading databases and to balance the trade-off between fast updates and fast queries, as databases typically cannot optimize both simultaneously. They also improve query performance on large datasets. The choice between using solutions like Memcached or Redis, or opting for a consolidated database and caching tier, depends on specific application needs.

Here's a neutral and interesting summary of the text: Developing an application that requires storing files in a NoSQL database like Couchbase can be beneficial, especially when storage space is limited or replication features are desired to prevent data loss. To achieve this, we need to set up Couchbase Server with a primary index using the Couchbase Query (CBQ) Client, and then configure a basic Node.js application that accepts file uploads, converts them into base64 strings, and stores these strings in Couchbase along with necessary metadata. The application uses Express.js for routing, Multer for handling file uploads, and N1QL queries to interact with the Couchbase database. By using this approach, we can efficiently store and manage files in a scalable and secure manner.

The text provides a step-by-step guide to creating a basic real-time desktop chat application using technologies like Angular 2, Couchbase, Socket.io, and Node.js, inspired by Slack's use of web technologies via GitHub's Electron platform. It details the prerequisites needed, including Couchbase Server for caching chat messages and Node Package Manager (NPM) for installing necessary frameworks. The guide suggests cloning a pre-existing Socket.io server code and configuring Couchbase to support N1QL queries. Further instructions include setting up an Electron project by installing dependencies and modifying configuration files to integrate a web-based interface into the desktop application. Finally, it explains how to run the server and desktop app simultaneously, allowing users to exchange messages stored in Couchbase, thereby demonstrating how a web application can be transformed into a cross-platform desktop application.

Couchbase has introduced new yum and apt-get repositories for easier installation of its products, providing a unified "couchbase-release" package for both RPM and DEB systems. This package simplifies the installation of the latest versions of Couchbase Server Enterprise Edition, Community Edition, and associated SDKs. For RHEL/CentOS and Ubuntu/Debian systems, users can configure these repositories and install Couchbase Server using straightforward commands via yum or apt-get. The package includes GPG keys for verifying signed packages, ensuring secure installations. Additionally, users are encouraged to update their package sources to the new "couchbase-release-1.0-0" to access the latest features, although it appears some older versions may not be available for installation through these commands. Comprehensive documentation is available for further guidance on installation and system requirements.

Beta 3 of the Couchbase ASP.NET Integration packages has been released on NuGet, offering implementations for connecting Couchbase Server with Microsoft ASP.NET, including Caching and Session providers, with future support for .NET Core anticipated. This new version introduces significant changes, notably the removal of the ClusterHelper, allowing for more flexible configurations by enabling applications to use buckets from multiple clusters, thereby enhancing scalability. While these alterations mean that Beta 3 is not a direct replacement for Beta 2, they facilitate better integration by refactoring the initialization and setup processes. Users can report bugs or request features via Jira, and the release includes several resolved issues and improvements, such as updates to NuGet packages and dependencies. The integration requires configuring the Couchbase .NET SDK and ASP.NET project settings to utilize the custom Session provider, ultimately leading to a scalable session management system powered by Couchbase.

The author discusses their experience with Apache Zeppelin, a web-based notebook for real-time analytics, and their efforts to extend its functionality by creating a Couchbase N1QL interpreter. While Zeppelin supports multiple backends through interpreters, the author focuses on enabling N1QL queries within Zeppelin by implementing a custom interpreter that handles query transformation and result formatting. This involves extending the abstract class org.apache.zeppelin.interpreter.Interpreter and implementing necessary methods for managing connections and interpreting queries. The author provides an example using game data to demonstrate the functionality and mentions potential improvements like autocomplete and support for geospatial queries and Couchbase FTS. The development of this plugin is shared on GitHub, encouraging feedback and contributions from the community.

At a presentation at JDays in Göteborg, Apache Zeppelin was introduced as a web-based notebook that facilitates interactive data analytics and supports various interpreters, including a seamless integration with Spark, which can utilize Couchbase's Spark Connector. Although building the latest version of Apache Zeppelin from source requires some technical setup, including dependencies like git and Maven, the process is straightforward. Users can enhance the Spark interpreter by adding dependencies such as the Couchbase Spark Connector and properties for accessing data like the beer-sample bucket. With Apache Zeppelin, users can create Spark Pads to read and manipulate data from Couchbase using Scala or Spark SQL, allowing for operations like filtering and grouping data, exemplified by queries on the beer-sample dataset. The document emphasizes the flexibility and potential of Apache Zeppelin for data analytics and encourages exploring its documentation for further learning.

With Couchbase Server 4.5, a new enhanced commandline query execution tool called "go_cbq" is being provided, offering capabilities such as scripting support and connection management. The author has been using go_cbq and appreciates its capabilities for editing and executing N1QL queries within the Visual Studio Code editor. To use this functionality, users must add the Couchbase bin directory to their PATH, start Visual Studio Code, open a folder, edit the tasks.json file with specific JSON code, and then launch the execute task to run go_cbq and display the output in the output window.

Joel Ruisi, a Community Champion in Florida, is known for his expertise in data management using Couchbase, a NoSQL database platform. Based in Orlando, he spends his workdays helping clients enhance their data utilization and appreciates Couchbase for its ease of setup and superior performance compared to other NoSQL competitors. Joel has leveraged Couchbase for various tasks such as caching slower data stores, system integration, and creating search applications, highlighting its versatility for numerous use cases. He expresses satisfaction with Couchbase's upcoming full-text search feature, which aligns with his wish for integrated search capabilities. Outside of work, Joel enjoys spending time with his family, fishing, and reading science fiction.

The blog post provides a guide on enabling Docker Remote API on Docker Machines created on Mac OS X, specifically addressing the challenges faced by users on OSX Mavericks due to updates in the curl utility that uses Apple's Secure Transport API instead of OpenSSL. It details the process of converting certificates to the P12 format required for successful communication with the Docker daemon via the Remote REST API. The author explains how to generate the necessary P12 certificate using OpenSSL and demonstrates how to use the updated curl command to interact with Docker, including retrieving image details and running a container. The post concludes with examples of invoking the REST API to manage Docker containers, emphasizing the importance of using the correct certificate format and password for secure access.

Next week, on March 17 and 18, Couchbase Mobile Engineers and the author will participate in Droidcon, a developer-focused mobile conference in San Francisco that specializes in Android development. The event offers attendees the opportunity to learn from industry experts about designing and developing Android applications using modern best practices. The author will deliver both a talk and a workshop, with the talk titled "What’s Peer-to-peer (P2P) and How to Create Offline Mobile Apps," which will cover the fundamentals of offline-first mobile applications and peer-to-peer syncing to eliminate the need for a server. The workshop, "Building the Kitchen Sync, an Android Workshop," will provide participants with hands-on experience integrating Couchbase Mobile into Android applications, revisiting concepts from the talk and incorporating Couchbase Sync Gateway and Couchbase Server. Attendees are encouraged to visit the Couchbase booth for some swag.

Couchbase Server has introduced the Sub-document API in its Developer Preview for version 4.5, providing a more efficient way to handle document mutations by allowing changes to specific parts of a document rather than the entire document. This feature is designed to optimize performance, especially for large documents or in scenarios with slow network conditions, by only sending and modifying the specific fragment that is changed. The API supports a variety of operations, such as mutations on nested elements, arrays, and dictionaries, as well as retrieval operations for JSON fragments. It offers a fluent interface with two types of builders: one for mutations and one for lookups, allowing for the chaining of multiple operations on a document, which are then executed atomically. However, this API is currently in an early Developer Preview stage, meaning it has not undergone full testing and should not be used in production environments, as its interfaces may change based on user feedback. The release notes for version 2.2.6 also highlight several bug fixes and improvements unrelated to the Sub-document API.

On March 8, 2016, a presentation and workshop titled "Creating Scalable and Secure Mobile Apps That Work Offline" will be held at O’Reilly Fluent 2016 in San Francisco, focusing on the development of mobile applications that synchronize across devices, platforms, and the web. The session, led by Wayne Carter and Nic Raboy, will emphasize the importance of building mobile apps that function effectively both online and offline, addressing user demands for immediate and reliable experiences. Attendees will gain insights into syncing, storing, and securing data using open-source technologies, specifically through the use of Ionic Framework and PouchDB, culminating in the creation of Android and iOS applications that seamlessly integrate with Couchbase Server via Couchbase Sync Gateway.

Brant Burnett, a lead developer at CenterEdge Software in Roxboro, North Carolina, specializes in creating software for the entertainment industry, particularly focusing on applications ranging from point-of-sale systems to online sales. In his leisure time, Brant enjoys spending time with his family and contributing to the .NET Couchbase SDK community. CenterEdge adopted Couchbase for its cloud solutions due to its ease of use and scalability, which significantly enhanced the performance of their applications, particularly in data-heavy areas like shopping carts. They transitioned to a full Couchbase platform, accommodating large datasets for multiple customers with ease. Brant is impressed by the new Query Workbench for N1QL and anticipates improvements such as full text search and advanced JOIN operations in future Couchbase versions. An admirer of author Patrick Rothfuss, Brant hopes for more frequent publications from him.

The project involves creating microservices that populate a Couchbase Server bucket at chosen intervals, running on an AWS EC2 server. To accommodate team members' preferences for different programming languages without incurring high costs from installing multiple server-side languages, Docker containers are used for each microservice. This approach keeps the server lightweight by removing containers after each run. Docker is configured on an Ubuntu 14.04 EC2 instance, and Dockerfiles serve as build scripts to define operating systems, packages, and files for creating Docker images. The process involves copying required files into the image and using the Node Package Manager (NPM) to install dependencies. The containers, once built, are run using Docker commands, with specific configurations to connect with Couchbase Server. This method allows projects in any programming language to interface with Couchbase Server, fulfilling the team's diverse programming needs efficiently.

In the era of constant connectivity, it is crucial to develop mobile applications that function seamlessly both online and offline, regardless of network conditions. The hands-on tutorial, "Creating scalable and secure mobile apps that work offline," offered at Fluent Conf 2016, provides guidance on building such applications with a consistent user experience. The session focuses on various aspects, including data syncing, storage, security, and cross-platform data modeling, using open-source technologies like Couchbase Mobile and PouchDB. Participants will gain insights into essential design patterns for developing robust mobile apps, with additional resources and support available through the Couchbase Mobile developer portal and forums.

Beacons, small Bluetooth Low Energy (BLE) devices, are gaining traction as tools for context-aware applications, with major platforms like Apple's iBeacons, Google's Eddystone, and AltBeacon supporting their use. These devices emit signals that applications can detect and respond to, providing dynamic content such as sales information in a supermarket or tracking user behavior at events with limited connectivity. Developers can repurpose beacons efficiently using tools like Couchbase Mobile, which allows offline functionality and synchronization of user interactions with beacons. Testing and development can be facilitated through solutions like Radius Networks' virtual machine image or PiBeacon, enabling experimentation without physical beacons. The text outlines how to integrate beacons with Android applications using the AltBeacon open-source library, highlighting the importance of configuring permissions and setting up background services for beacon detection. The process includes initial setup, region monitoring, and activity launching based on beacon presence, demonstrating how beacons can enhance user experiences through tailored app interactions.