We just introduced The IBM Cloud Developer Console. Extending the current IBM Cloud Mobile Dashboard, this new experience goes beyond mobile and introduces new tools for quickly creating Cloud Native applications across web, mobile and backend. They aim to greatly cut down on development time by generating application starters with all the necessary boilerplate, build and configuration code, so that developers can start coding business logic faster.
What is Cloud Native?
Cloud Native represents philosophies of application development enabled by Cloud technology. These applications take advantage of scalability, flexibility, continuous deployment, DevOps practices, analytics and cognitive capabilities. To incorporate those characteristics into your software lifecycle, it’s important to build the applications with a different set of principles than traditional monolith approaches. The IBM Cloud Developer Console makes it easy to create Cloud Native applications that follow modern best practices by generating pre-configured application templates necessary for your microservices architecture.
What makes up a microservices architecture?
Cloud Native applications require building blocks composed of application components, infrastructure and data services. The diagram below is an example of how you could fit those building blocks together to create an application for mobile and web.
To learn more about IBM’s best practices around Cloud Native architectures, check out this series of blogs, videos and guides.
With this approach, you can typically spend a lot of time simply setting up each of the microservices and connecting them to other components. The new IBM Cloud Developer Console accelerates this process by scaffolding ready-to-code applications complete with integration to database, cognitive and security services. With our initial launch, we’re enabling Mobile Apps, Web Apps, Backend for Frontend, and Microservices. More to come in the future!
A developer can now build out Cloud Native applications using our patterns-first approach. You simply select the type of building block you’d like to create followed by which services you’d like to incorporate into your application (i.e., Cloudant database, WatsonConversation, Push Notifications). After choosing a language, the console will generate a starter project for you to download and edit, deploy locally or to IBM Cloud, and add more services. Not sure which pattern to choose? Here’s a short description of those available in our first release.
Mobile App –If you’re building a client-side mobile app, start with this pattern. This will enable you to easily integrate with mobile services like Push and Mobile Analytics, Data services like Object Store and Cloudant, and even add security using AppID. The starter will also give you the ability to easily connect with a backend starter.
Web App – If you’re building a client-side web app, start with this pattern. Depending on the pattern, you can download runnable code pre-baked with modern web technologies like gulp, sass, react, webpack, and more.
Backend for Frontend – If you’re implementing logic to support a mobile or web front end, start with this pattern. This pattern allows you to easily integrate with Data, Security and other Backend patterns.
Microservice –If you’re implementing server-side logic for a single function reusable by multiple clients, use this pattern to get your starter code. This will come with a pre-configured manifest.yml or Dockerfile, so you can run it as a CloudFoundry application or in a Docker container anywhere.
How to get started?
The new IBM Cloud Developer experience offers two tools to get started: Command Line Interface and The IBM Cloud Developer Console.
Let’s talk about building something familiar, a To-Do list application. There are 3 main components to this application: a web front-end responsible for presenting the user with a slick UI, a backend that will hold all the logic, and finally a database to persist all the todo items.Unlike traditional monolith applications, a microservices architecture requires the UI and backend code to be split into two separate applications. This offers many benefits:
Allows the UI and the backend to run on different technology stacks – whatever is best for it’s function.
Independent software lifecycle means faster development, deployment, and scaling.
Components can be reused and replaced as necessary. If we decide to build a mobile front-end in the future, it can reuse the backend application that already exists.
With The IBM Cloud Developer Console, we don’t need to waste hours or days researching tools and frameworks or setting up the stack for each microservice. Instead, we can simply pick a combination frameworks and services from a curated list of starters, then generate and run the code locally or on IBM Cloud using the CLI or web UI.
First, to set up the backend of our application, start by creating the Backend starter with Node. This generates a skeleton node.js application. It comes ready with express and RESTful API endpoints for CRUD operations with the todo items.
Second, to add a database, navigate to the project’s dashboard. Click the Data tab and add a Cloudant database. Then visit the Code tab to regenerate the node.js starter code, which is now pre-configured with the Cloudant SDK and code to help you get started.
Third, create the UI with a web app. Pick the React + Webpack starter. This will generate a front-end starter project with react, babel, webpack, and all the modern technology to help build a UI.
Ready to start creating your projects? Login to IBM Cloud and select “Web and Mobile” from the left navigation menu.
IBM Cloud Schematics is a tool that uses Terraform to provision and manages infrastructure resources, Cloud Foundry applications, services, Kubernetes clusters and much more using the code in a configuration file(s).