Cisco cms api. Dries Buytaert

Setting up Cisco Meeting Server.Part 1

Cisco Meeting Server is a Secure on-premises Video Conferencing solution that is easy to configure and for that, you just need to have some understanding of CMS components. Most new users get confused with what all is required to know and configure. In this blog, we will cover the deployment models and basic configuration to set up components.

CMS comes with hardware as CMS 1000 and CMS 2000. CMS1K and CMS2K are basically UCS-B servers. CMS1K is the UCS-C220 server and CMS2K is the UCS-B200 server. You can refer to the datasheets provided by Cisco for more details.

Based on Hardware, you can scale your HD calls per second. CMS1K supports 30 x 1080P 60 fps calls, 60 x 1080p 30 fps calls, 120 x 720p 30 fps calls. CMS2K supports 218 x 1080P 60 fps calls, 437 x 1080p 30 fps calls, 875 x 720p 30 fps calls.

You need to understand the deployment models and finalize the architecture you want. For this, you need to understand your environment first and then decide what deployment setup out of below you want in your environment.

Single Combined Server Model

In this architecture, you basically deploy one Cisco meeting server with all features available. Deploy this model with Cisco Expressway Pair.

Expressway Edge server will act as edge server placed in DMZ in your environment. Connect Expressway Core with CMS and CUCM with CMS.

Scalable And Resilient Server Model

In this architecture, you deploy multiple CMS in high availability. The architecture enables you to expand as your Video conferencing requirement grows. Call capacity can be increased by adding more Meeting Servers. In this clustering, the call bridges will increase the conference capacity. These Meeting servers can be in the same location or different geographical locations. While configuring the model, you need to make sure that load balancing across call bridge groups is properly configured.

There are two layers to the Cisco Meeting Server software: A Platform and an Application.

The Platform is configured through the Mainboard Management Processor (MMP). The MMP is used for low-level bootstrapping, and configuration via its command-line interface. For example, the MMP is used to enable the Web Bridge, Database clustering, and various other components.

The Application runs on the MMP platform. Administration of the application level (call and media management) can be done via the Call Bridge’s Web Admin interface or through the Application Programming Interface (API) if you prefer. The API uses HTTPS as a transport mechanism and is designed to be scalable in order to manage the potentially very large numbers of active calls and spaces available in a deployment.

Cisco Meeting Server Installation

Cisco recommends the UCS platform for the Cisco Meeting Server. You can download the ova file from software.cisco.com. Deploy the VM OVA Template. After the deployment is over, open the server console and log in. The default CMS login/password is admin/admin. The system will prompt you to change the password.

The below 9 steps are the basic requirement for CMS which you will need to do everywhere and set up basic Webrtc.

Assign IP Address and gatewayipv4 a add x.x.x.x/y z.z.z.z

Where x.x.x.x represents IP Address, Y represents subnet and z.z.z.z represents GatewayFor example: ipv4 a add 172.16.1.2/24 172.16.1.1

Configure DNS IP and domain

Then you need to configure DNS.

Add NTP Server address

Change default time zone

Change time zone as per requirement.

Cisco will map the mac address with the license and share a license file. Rename the file to cms.lic

The next step is to put the cms.lic file in CMS. Use WinSCP for this.

Configure Webadmin

Webadmin will enable the GUI application access. To enable this, you need either self-signed or CA-signed certificates. Use the below command to generate CSRs.

Note – Server Certificates must have SAN entries and Server and client authentication keys under the Enhanced key usage section. Check with your CA Administrator as this is required.

Once you have webadmin certs and root certs uploaded in CMS. Then configure certs and enable webadmin. It is recommended that you change webadmin GUI interface to use a port other than 443 as that will be used by clients for Webrtc purposes.

Webadmin cert cms.key cms.cer root.cer

Now your webadmin page will open on 445 port.

Configure XMPP.

XMPP handles registration and authentication from CMA/Webrtc clients. Everything registers to XMPP server such as Callbridge

The XMPP service in CMS is used to handle all registration and authentication for Cisco Meeting Apps (CMA), including the web-based WebRTC CMA client. The Call Bridge itself also acts as an XMPP client for authentication purposes and will therefore need to be configured as other clients.

To configure use below commands –

xmpp certs cms.key cms.crt root.cer

Create Call bridge

The Call Bridge is the one service present in every CMS deployment. The Call Bridge is the main conferencing engine. It also provides the SIP interface, so that calls can be routed to/from it from external call control, such as the Cisco Unified CM.

xmpp callbridge add CFBCMS

callbridge certs cms.key cms.crt root.cer

Copy the secret key.

Put unique call bridge name in GUI with password (Secret key) and name (CFBCMS) submit

Server address – Where should this callbridge register to? If you have multiple XMPP, then let DNS srv do the job. If you have only one, you can leave this blank

_xmpp-component._tcp. port 5223

Create as many as srv with priorities to configure XMPP High availability.

Webbridge (handling WebRTC/CMA)

If you plan to allow users to access their Spaces in Cisco Meeting Server via a browser, then you will need to configure the Web Bridge. It is the server role that enables users to manage and connect to their Spaces as well as allow outside participants into conferences using only a WebRTC-enabled browser.

Use below command line –

webbridge http-redirect enable (will redirect users from port 80 to 443)

webbridge certs cms.key cms.crt root.cer

webbridge trust (Command will enable join button but you also need to tell callbridge which webbridge to trust)

Go to GUI Configuration General

Guest account JID domain – Domain name

Note – If you are using Expressway pair in your environment then your Expressway E needs to be signed by Public CA. If not, then you need to sign Webbridge certificate with Public CA so your WebRTC page opens on HTTPS and does not give you a “Your connection is not private” error.

After you follow the above steps, then you have completed the basic setup for CMS and Webrtc.

Now, if you have queries against database and API configuration. Stay tuned for the next article which will cover clustering of XMPP, database, Callbridges, and API configuration.

We hope this article gives you an understanding of the Cisco Meeting Server Basic setup. If you are looking for consulting, advisory and professional services to deploy a Collaboration Environment for your organization and other services too then our techs at Zindagi can help.

Zindagi Technologies Pvt. Ltd. is an IT consultancy and professional services organization based out of New Delhi, India. We have expertise in planning, designing, and deployment of collaboration environments, large-scale data centers, Private/Public/Hybrid Cloud solutions, and believing in “Customer Satisfaction”, we make sure that all the requirements are fulfilled from our side. You can contact us on our number 919773973971.

AuthorRahul Bhukal Sr. Collaboration Consultant

Dries Buytaert

We compare REST, JSON:API and GraphQL — three different web services implementations — based on request efficiency, operational simplicity, API discoverability, and more.

The web used to be server-centric in that web content management systems managed data and turned it into HTML responses. With the rise of headless architectures a portion of the web is becoming server-centric for data but client-centric for its presentation; increasingly, data is rendered into HTML in the browser.

This shift of responsibility has given rise to JavaScript frameworks, while on the server side, it has resulted in the development of JSON:API and GraphQL to better serve these JavaScript applications with content and data.

In this blog post, we will compare REST, JSON:API and GraphQL. First, we’ll look at an architectural, CMS-agnostic comparison, followed by evaluating some Drupal-specific implementation details.

It’s worth noting that there are of course lots of intricacies and it depends when comparing these three approaches. When we discuss REST, we mean the typical REST API as opposed to one that is extremely well-designed or following a specification (not REST as a concept). When we discuss JSON:API, we’re referring to implementations of the JSON:API specification. Finally, when we discuss GraphQL, we’re referring to GraphQL as it used in practice. Formally, it is only a query language, not a standard for building APIs.

The architectural comparison should be useful for anyone building decoupled applications regardless of the foundation they use because the qualities we will evaluate apply to most web projects.

To frame our comparisons, let’s establish that most developers working with web services care about the following qualities:

• Request efficiency: retrieving all necessary data in a single network round trip is essential for performance. The size of both requests and responses should make efficient use of the network.
• API exploration and schema documentation: the API should be quickly understandable and easily discoverable.
• Operational simplicity: the approach should be easy to install, configure, run, scale and secure.
• Writing data: not every application needs to store data in the content repository, but when it does, it should not be significantly more complex than reading.

We summarized our conclusions in the table below, but we discuss each of these four categories (or rows in the table) in more depth below. If you aggregate the colors in the table, you see that we rank JSON:API above GraphQL and GraphQL above REST.

If you’re not familiar with JSON:API or GraphQL, I recommend you watch the following two short videos. They will provide valuable context for the remainder of this blog post:

Request efficiency

Most REST APIs tend toward the simplest implementation possible: a resource can only be retrieved from one URI. If you want to retrieve article 42, you have to retrieve it from https://example.com/article/42. If you want to retrieve article 42 and article 72, you have to perform two requests; one to https://example.com/article/42 and one to https://example.com/article/72. If the article’s author information is stored in a different content type, you have to do two additional requests, say to https://example.com/author/3 and https://example.com/author/7. Furthermore, you can’t send these requests until you’ve requested, retrieved and parsed the article requests (you wouldn’t know the author IDs otherwise).

Consequently, client-side applications built on top of basic REST APIs tend to need many successive requests to fetch their data. Often, these requests can’t be sent until earlier requests have been fulfilled, resulting in a sluggish experience for the website visitor.

GraphQL and JSON:API were developed to address the typical inefficiency of REST APIs. Using JSON:API or GraphQL, you can use a single request to retrieve both article 42 and article 72, along with the author information for each. It simplifies the developer experience, but more importantly, it speeds up the application.

Finally, both JSON:API and GraphQL have a solution to limit response sizes. A common complaint against typical REST APIs is that their responses can be incredibly verbose; they often respond with far more data than the client needs. This is both annoying and inefficient.

GraphQL eliminates this by requiring the developer to explicitly add each desired resource field to every query. This makes it difficult to over-fetch data but easily leads to very large GraphQL queries, making (cacheable) GET requests impossible.

JSON:API solves this with the concept of sparse fieldsets or lists of desired resource fields. These behave in much the same fashion as GraphQL does, however, when they’re omitted JSON:API will typically return all fields. An advantage, though, is that when a JSON:API query gets too large, sparse fieldsets can be omitted so that the request remains cacheable.

Documentation, API explorability and schema

As a developer working with web services, you want to be able to discover and understand the API quickly and easily: what kinds of resources are available, what fields does each of them have, how are they related, etc. But also, if this field is a date or time, what machine-readable format is the date or time specified in? Good documentation and API exploration can make all the difference.

GraphQL has superior API exploration thanks to GraphiQL (demonstrated in the video above), an in-browser IDE of sorts, which lets developers iteratively construct a query. As the developer types the query out, likely suggestions are offered and can be auto-completed. At any time, the query can be run and GraphiQL will display real results alongside the query. This provides immediate, actionable feedback to the query builder. Did they make a typo? Does the response look like what was desired? Additionally, documentation can be summoned into a flyout, when additional context is needed.

On the other hand, JSON:API is more self-explanatory: APIs can be explored with nothing more than a web browser. From within the browser, you can browse from one resource to another, discover its fields, and more. So, if you just want to debug or try something out, JSON:API is usable with nothing more than cURL or your browser. Or, you can use Postman (demonstrated in the video above) — a standalone environment for developing on top of an any HTTP-based API. Constructing complex queries requires some knowledge, however, and that is where GraphQL’s GraphiQL shines compared to JSON:API.

Operational simplicity

We use the term operational simplicity to encompass how easy it is to install, configure, run, scale and secure each of the solutions.

The table should be self-explanatory, but we want to provide some more details about the scalability row. To scale a REST-based or JSON:API-based web service so that it can handle a large volume of traffic, you can use the same approach websites (and Drupal) already use, including reverse proxies like Varnish or a CDN. To scale GraphQL, you can’t rely on HTTP caching as with REST or JSON:API without persisted queries. Persisted queries are not part of the official GraphQL specification but they are a widely-adopted convention amongst GraphQL users. They essentially store a query on the server, assign it an ID and permit the client to get the result of the query using a GET request with only the ID. Persisted queries add more operational complexity, and it also means the architecture is no longer fully decoupled — if a client wants to retrieve different data, server-side changes are required.

Writing data

For most REST APIs and JSON:API, writing data is as easy as fetching it: if you can read information, you also know how to write it. Instead of using the GET HTTP request type you use POST and PATCH requests. JSON:API improves on typical REST APIs by eliminating differences between implementations. There is just one way to do things and that enabled better, generic tooling and less time spent on server-side details.

The nature of GraphQL’s write operations (called mutations) means that you must write custom code for each write operation; unlike JSON:API the specification, GraphQL doesn’t prescribe a single way of handling write operations to resources, so there are many competing best practices. In essence, the GraphQL specification is optimized for reads, not writes.

On the other hand, the GraphQL specification supports bulk/batch operations automatically for the mutations you’ve already implemented, whereas the JSON:API specification does not. The ability to perform batch write operations can be important. For example, in our running example, adding a new tag to an article would require two requests; one to create the tag and one to update the article. That said, support for bulk/batch writes in JSON:API is on the specification’s roadmap.

Drupal-specific considerations

Up to this point we have provided an architectural and CMS-agnostic comparison; now we also want to highlight a few Drupal-specific implementation details. For this, we can look at the ease of installation, automatically generated documentation, integration with Drupal’s entity and field-level access control systems and decoupled filtering.

Drupal 8’s REST module is practically impossible to set up without the contributed REST UI module, and its configuration can be daunting. Drupal’s JSON:API module is far superior to Drupal’s REST module at this point. It is trivial to set up: install it and you’re done; there’s nothing to configure. The GraphQL module is also easy to install but does require some configuration.

Client-generated collection queries allow a consumer to filter an application’s data down to just what they’re interested in. This is a bit like a Drupal View except that the consumer can add, remove and control all the filters. This is almost always a requirement for public web services, but it can also make development more efficient because creating or changing a listing doesn’t require server-side configuration changes.

Drupal’s REST module does not support client-generated collection queries. It requires a REST Views display to be setup by a site administrator and since these need to be manually configured in Drupal; this means a client can’t craft its own queries with the filters it needs.

JSON:API and GraphQL, clients are able to perform their own content queries without the need for server-side configuration. This means that they can be truly decoupled: changes to the front end don’t always require a back-end configuration change.

These client-generated queries are a bit simpler to use with the JSON:API module than they are with the GraphQL module because of how each module handles Drupal’s extensive access control mechanisms. By default JSON:API ensures that these are respected by altering the incoming query. GraphQL instead requires the consumer to have permission to simply bypass access restrictions.

Most projects using GraphQL that cannot grant this permission use persisted queries instead of client-generated queries. This means a return to a more traditional Views-like pattern because the consumer no longer has complete control of the query’s filters. To regain some of the efficiencies of client-generated queries, the creation of these persisted queries can be automated using front-end build tooling.

What does this mean for Drupal’s roadmap?

Drupal grew up as a traditional web content management system but has since evolved for this API-first world and industry analysts are praising us for it.

As Drupal’s project lead, I’ve been talking about adding out-of-the-box support for both JSON:API and GraphQL for a while now. In fact, I’ve been very bullish about GraphQL since 2015. My optimism was warranted; GraphQL is undergoing a meteoric rise in interest across the web development industry.

Based on this analysis, for Drupal core’s needs, we rank JSON:API above GraphQL and GraphQL above REST. As such, I want to change my recommendation for Drupal 8 core. Instead of adding both JSON:API and GraphQL to Drupal 8 core, I believe only JSON:API should be added. That said, Drupal’s GraphQL implementation is fantastic, especially when you have the developer capacity to build a bespoke API for your project.

On the four qualities by which we evaluated the REST, JSON:API and GraphQL modules, JSON:API has outperformed its contemporaries. Its web standards-based approach, its ability to handle reads and writes out of the box, its security model and its ease of operation make it the best choice for Drupal core. Additionally, where JSON:API underperformed, I believe that we have a real opportunity to contribute back to the specification. In fact, one of the JSON:API module’s maintainers and co-authors of this blog post, Gabe Sullice (Acquia), recently became a JSON:API specification editor himself.

This decision does not mean that you can’t or shouldn’t use GraphQL with Drupal. While I believe JSON:API covers the majority of use cases, there are valid use cases where GraphQL is a great fit. I’m happy that Drupal is endowed with such a vibrant contributed module ecosystem that provides so many options to Drupal’s users.

I’m excited to see where both the JSON:API specification and Drupal’s implementation of it goes in the coming months and years. As a first next step, we’re preparing the JSON:API to be added to Drupal 8.7.

Special thanks to Wim Leers (Acquia) and Gabe Sullice (Acquia) for co-authoring this blog post and to Preston So (Acquia) and Alex Bronstein (Acquia) for their feedback during the writing process.

Dries Buytaert is an Open Source advocate and technology executive. than 10,000 people are subscribed to his blog. Sign up to have new posts emailed to you or subscribe using RSS. Write to Dries Buytaert at dries@buytaert.net.

Setup the Cisco Webex API trigger to run a workflow which integrates with the Google Sheets API. Pipedream’s integration platform allows you to integrate Cisco Webex and Google Sheets remarkably fast. Free for developers.

Popular Cisco Webex and Google Sheets Triggers #

Emit new event when a message is added. See the docs here

Emit new events each time a row or rows are added to the bottom of a spreadsheet. To use this source with a spreadsheet in a Shared Drive, use the New Row Added (Shared Drive, Instant) source instead.

Emit new events each time a row or rows are added to the bottom of a spreadsheet in a shared drive

Emit new event each time a row or cell is updated in a spreadsheet. To use this source with a spreadsheet in a Shared Drive, use the New Updates (Shared Drive, Instant) source instead.

Emit new event each time a row or cell is updated in a spreadsheet in a shared drive

Popular Cisco Webex and Google Sheets Actions #

Creates a room. The authenticated user is automatically added as a member of the room. See the docs here

Add a single row of data to Google Sheets

Post a plain text or rich text message, and optionally, a file attachment, to a room. See the docs here

Add multiple rows of data to a Google Sheet

Retrieve messages in a specific room. See the docs here

Overview of Cisco Webex #

Some things you can build using the Cisco Webex API include:

• A bot that can perform various tasks such as scheduling meeting, sendingreminders, and taking minutes
• An application that can help manage your team’s tasks and to-do lists
• A tool that can help transcribe meeting notes into text format
• A system that can automatically record and archive your team’s Webex meetings

Connect Cisco Webex #

import axios from @pipedream/platform export default defineComponent( props: cisco_webex: type: app, app: cisco_webex. async run(steps, ) return await axios(, url: `https://webexapis.com/v1/people/me`, headers: Authorization: `Bearer this.cisco_webex.auth.oauth_access_token`. ). )

Overview of Google Sheets #

Some examples of things you can build using the Google Sheets API include:

• A web app that lets users input data into a Google Sheet
• A script that automatically updates a Google Sheet with data from anothersource
• A tool that generates graphs and charts from data in a Google Sheet
• A service that sends data from a Google Sheet to another API or application

Connect Google Sheets #

import axios from @pipedream/platform export default defineComponent( props: google_sheets: type: app, app: google_sheets. async run(steps, ) return await axios(, url: `https://www.googleapis.com/oauth2/v1/userinfo`, headers: Authorization: `Bearer this.google_sheets.auth.oauth_access_token`. ). )

Related Videos #

Learn how you can use Pipedream event sources and serverless workflows to listen for new mentions, analyze the sentiment of each Tweet using the npm sentiment package (https://www.npmjs.com/package/sentiment), and then save that data to Google Sheets in real-time.

Community Posts #

This is something that’s been kicking around my head for a week or so and today I thought I’d try it. It ended up taking about 20 minutes total and 10 lines of code, of which 5 are a function I copied and pasted. While what I built is kind of trivial, I’m blown away by how much was done by built-in functions with Pipedream and how little work I had to do myself. In fact, most of my time was spent in setting stuff up outside of Pipedream itself. Alright, so what did I build?

A few months ago, I blogged about how I used Pipedream and Google Sheets to create a bot. The idea was simple. read a sheet. select a random row. and use that as the source of a new Tweet. I was thinking about this recently and how useful Google Sheets can be as a light weight CMS and figured out another interesting use case. scheduling.

One of the nice features SuperSaaS is a credit system which allows end-users to buy credit once and then easily pay for appointments without needing to go through the checkout each time. There are multiple things that can affect a credit balance. Credit purchases and new appointment, obviously, but also refunds due to canceled appointments, and manual credit adjustments by a superuser. This post is a step-by-step tutorial for setting up the logging of user credit information to a Google Sheet using Pipedream, a powerful API integration service.

What are you missing in Cisco Meeting Server?

This post is to list some of the gaps of Cisco Meeting Server highlighted by our customers migrating from Cisco TelePresence Server to Meeting Server and partners who deploy Cisco videoconferencing solutions.

The Cisco Meeting Manager tool does not provide camera snapshots. See CMM 2.6 user guide for video operators for more.

There used to be a native lecture more for Telepresence Server conferences. Though there are guides about how to configure it with API (see https://kb.acano.com/content/9/68/en/how-do-i-set-up-%E2%80%9Clecture-mode%E2%80%9D.html) the hand raising feature is missing.

CMS can record meetings (special license is required) but it only stores recording on a NFS. No interface to play recordings, manage access rights etc.

Lots of clients want to start a meeting with a push of a button and have a predefined list of participants to be dialed and joined automatically.

CMS meetings can be streamed to a predefined IP, but you have to deploy some 3rd party media streaming engine to capture it and broadcast to users.

For Cisco UCM

Discover PhoneUP. all-in-one bundle for CUCM and Cisco BE 6000/7000:

Record. call recording for Cisco IP telephony;

Directory. caller ID, missed calls and contact search.

Lock. Cisco IP phone lock/unlock app;

Become a Partner

If your company deploys Cisco collaboration solutions and contact center software, your are welcome to join our partner network!

Ask a question

Find out about the price and features.

Send us your question and we will get back to you in 1 business day or earlier.

IncludeComponent( aurus:form.result.new, short, Array( SEF_MODE = N, WEB_FORM_ID = 15, LIST_URL = /contacts/sent.php, EDIT_URL = /include/bottom_feedback.php, CHAIN_ITEM_TEXT =. CHAIN_ITEM_LINK =. CACHE_TYPE = A, CACHE_TIME = 3600, VARIABLE_ALIASES = Array( WEB_FORM_ID = WEB_FORM_ID, RESULT_ID = RESULT_ID ) ) );?