Tips

Tips

• How to prepare your own container development kit

  A container development kit helps confederate containerized application development and transition developed components between clusters. Here's how to create your own.  Continue Reading

• How to build microservices with Spring Boot and Spring Cloud

  Spring Boot and Cloud can certainly help developers tackle microservices, but it's not for everybody and, unfortunately, there are a few important limitations to consider.  Continue Reading

• 3 serverless platform approaches to consider

  There are several ways to approach serverless, and each has pros and cons. Learn where cloud, open source and the more traditional platforms fit into the serverless conversation.  Continue Reading

• 3 ways to minimize critical container vulnerabilities

  Containers are complex, and it takes some work to keep your container components and images safe from attack. Here are three critical container development security practices.  Continue Reading

• Combining serverless and microservices has its benefits

  Uncover the advantages that result from coupling serverless with microservices, and see how cloud providers prepare for customers to use these technologies together.  Continue Reading

• Pair AWS with microservices deployment to meet CI/CD goals

  When combined with microservices, these AWS offerings can provide an easier way to adopt a fully Agile development methodology.  Continue Reading

• Practical ways to implement function as a service

  Developers are ready to work with function as a service but still need some guidance. Learn about FaaS implementation models and which FaaS platform offering is for you.  Continue Reading

• The top ways microservices impact EDI processes

  B2B integration has changed, and traditional EDI transaction methods may not meet modern needs. Here is how microservices can help organizations simplify today's complex B2B endpoints.  Continue Reading

• To address microservices issues, turn to OOP principles

  Developers may graduate to microservices from object-oriented programming, but the fundamental principles of OOP still apply, even if the techniques have changed.  Continue Reading

• 5 tips to help effectively manage container components

  The layered approach is commonly used with Docker containers, but it's important to keep container components under control. Here are five crucial tips.  Continue Reading

• How to use microservices to manage serverless APIs

  Monolithic applications may be a little bit heavy for development of serverless APIs, but microservices can make all the difference. Here's how to make it work.  Continue Reading

• Open source tools to consider for your RESTful APIs

  Software teams don't have to break the bank when they shop for RESTful API management tools. The right combination of tools that use open source code can help manage the whole lifecycle at low cost.  Continue Reading

• What to look for in an API development SaaS platform

  Not all SaaS API development platforms are made the same. Learn about the fundamental capabilities that API SaaS tools should provide and discover some popular options.  Continue Reading

• 5 fundamental steps of managing APIs

  API management is undeniably essential, but it requires a comprehensive plan. Here are the five steps of an API management strategy and advice on how to complete each one.  Continue Reading

• A quick primer on microservices load balancing

  Work distribution in microservices is tricky; without the right strategy, you risk that workloads won't scale effectively. Here's how to nail down load balancing for microservices.  Continue Reading

• How to choose between serverless and containerized microservices

  Explore the intricacies of serverless microservices and container microservices to discover which development requirements are crucial to your ultimate decision.  Continue Reading

• Some tricks to help manage load balancing in microservices

  Load balancing is a critical, and potentially thorny, part of cloud-native microservices management. Consider these methods and tools that can help address these challenges.  Continue Reading

• How to make automation part of your microservices security

  It's not ideal to manually test and secure a microservices environment. Consider automation tools when you need to fortify your microservices security plan.  Continue Reading

• 5 basic SOA principles that still apply to microservices

  Microservices often replace SOA, but these two architecture styles are still similar. Here are five basic SOA principles that never went away.  Continue Reading

• 3 ways to prep microservices applications for big data

  It's easy for the expansion of big data to spin out of control in a distributed architecture. Think carefully about database management to avoid performance-killing bottlenecks.  Continue Reading

• 5 critical components of a microservices security plan

  Microservices have introduced a wave of security complexity. Before you run containerized microservices in production, carefully review these five critical security practices.  Continue Reading

• How to approach mobile optimization with less risk

  Microservices and containers can help boost mobile optimization, but it's not automatic. Development teams must think carefully about tooling choices, API creation and more.  Continue Reading

• Unlock distributed analytics with a microservices approach

  Mobility creates distributed computing environments, which lead to a scenario where some of the older analytics processes are no longer useful. Distributed analytics with microservices can help.  Continue Reading

• How Java EE development has kept up with microservices

  Java EE is mature technology, but it will continue to evolve in ways that can fit nicely into a microservices architecture.  Continue Reading

• Understand business logic to fortify microservices design

  Before software teams introduce microservices, they must take a critical look at the business logic that frames their architecture because, as contexts change, so does the logic.  Continue Reading

• How to manage distributed apps built on microservices

  Distributed applications can clearly benefit from the architectural benefits of microservices, but that has traditionally come with certain drawbacks. Discover how it's become easier to manage distributed applications built on microservices due to ...  Continue Reading

• How to move beyond REST for microservices communication

  Despite its popularity, REST isn't always the best protocol for microservices communication. There are other options that may be a better fit.  Continue Reading

• Docker and Kubernetes monitoring tools that work on microservices

  What does it take to manage your containers? Explore a wide range of monitoring tools specifically suited for Docker and Kubernetes.  Continue Reading

• How to match microservices middleware to your mission

  Microservices middleware strategies require an understanding of goals, state control and other key factors. Discover everything you should consider and how it affects your needs.  Continue Reading

• Open source microservices management trends alter software delivery

  Open source trends and projects have shaken up the software delivery landscape by aiming to run and manage microservices in cloud-native environments.  Continue Reading

• Use API gateways to aid microservices communication, security

  Discover where API gateways fit into microservices architectures to help manage interactions between client applications and users.  Continue Reading

• Blockchain-microservices pairing not an enterprise reality yet

  Despite some specific use cases, experts don't expect to see many enterprises combine blockchain and microservices -- at least, not yet.  Continue Reading

• Best tools and methods for designing RESTful APIs

  Approaches to RESTful API design may differ, but five essential elements to API design exist to help guide your tool selection conundrum and solve your RESTful API design problems.  Continue Reading

• Achieve reactive microservices architecture with minimal effort

  Reactive systems philosophy lends itself to microservices architecture because it stresses four core principles of responsivity, resilience, elasticity and message-driven communication.  Continue Reading

• Kubernetes service discovery tactics boost microservices

  Customize or automate a containerized application's service discovery exactly to your preference by mastering a collection of Kubernetes features.  Continue Reading

• Utilize microservices to support a 5G network architecture

  To satisfy next-level network promises, 5G networks should be supported by a microservices-based infrastructure, as monolithic architectures won't meet demands.  Continue Reading

• How gRPC improves microservices load balancing on Kubernetes

  Kubernetes networking can be a challenge, but the gRPC protocol can help software pros focus on the application logic rather than worry about how to handle network request calls.  Continue Reading

• How to build a layered approach to security in microservices

  Make your microservices-based app as secure as possible by adopting an in-depth, layered security strategy because no single traditional approach can reliably do the job.  Continue Reading

• Serverless vs. containers: What's best for event-driven apps?

  Serverless and containers give teams new options to host event-driven applications, but each has pros and cons. Decide which platform is best for your app to avoid a costly mistake.  Continue Reading

• How to control state for so-called stateless microservices

  How do you control state in a stateless microservices environment? Front-end and back-end state control can be two viable approaches, and one requires less work than the other.  Continue Reading

• Modern deployment models put a new spin on componentization

  Developers can use containers, serverless and microservices to strengthen app composability, but there are tradeoffs to consider. Discover the brave new world of componentization.  Continue Reading

• How to ease the pain of Kubernetes upgrades with automation

  Although Kubernetes aims to automate container management, Kubernetes upgrades are still a tedious, manual process. Learn about the tooling that helps automate this task.  Continue Reading

• A comparison of microservices and functional programming concepts

  While often seen together, microservices and functional programming are two different animals. Find out where these disciplines overlap and, more importantly, where they don't.  Continue Reading

• How to adapt API management for serverless architecture

  It's critical to understand what will happen to legacy APIs when you transition to a serverless architecture. Discover how to properly adapt API management for this new paradigm.  Continue Reading

• Unpacking the event-driven microservices approach

  Event-driven applications can be beneficially combined with microservices architectures, and finding the best method to merge them relies on analyzing orchestration options.  Continue Reading

• When is serverless technology best for app modernization?

  Serverless has emerged as a viable option for app modernization, but it's not always a perfect fit. Rich Sharples, Red Hat senior director, explains the considerations to take.  Continue Reading

• The pros and cons of serverless architecture

  The serverless trend may hold advantages for developers, but consider the trade-offs. There are many aspects of serverless computing that developers should understand.  Continue Reading

• Modernizing legacy applications with minimal strain

  Many different challenges can occur as a result of modernizing legacy applications. Luckily, there are a multitude of options at your disposal to overcome these obstacles.  Continue Reading

• Front-end microservices offer flexibility for developers

  Looking to create a stronger and more transparent relationship between front-end and back-end components? Learn how microservices can help make that dream a reality.  Continue Reading

• The fundamental differences between microservices and SOA

  Microservices are all the rage, but those still used to SOA may feel a little left behind. Discover what SOA developers need to know about microservices and how to make the switch.  Continue Reading

• How proper networking supports microservices security

  Security shouldn't be an afterthought when it comes to microservices. Learn about the challenges of microservices security and how strong network management can help.  Continue Reading

• How to mitigate the complexity of microservice communication

  As development teams continue to adopt microservices, they must ensure communication errors do not get out of control. Here are some tools and techniques to do just that.  Continue Reading

• Moving data from a monolith to microservices architecture

  Monolithic apps may contain a wealth of data within them. Moving to microservices means you need a plan for storing, accessing and backing up in a microservice database.  Continue Reading

• Implementing microservices architecture best practices

  Addressing the performance issues of microservice architectures can be quite challenging. Yet, using the right tools or practices at the right time and place will give you a boost.  Continue Reading

• Microservices challenges include latency, but it can be beat

  When working with microservices, latency is the cost. Read about the weak points of microservices and the necessary workarounds to latency and experience issues.  Continue Reading

• How AWS Lambda functions and API Gateway aid modernization

  Some organizations avoid modernization because of changes that need to be made to servers. But using AWS Lambda with API Gateway offers a way to modernize without the provisioning.  Continue Reading

• Developers, prepare for the caveats of serverless frameworks

  While serverless has gained the attention of many developers, those that adopt serverless must stay on top of issues that it may bring, including portability challenges.  Continue Reading

• Build consistent, resilient microservices with Kubernetes

  A microservices architecture brings many changes to an enterprise IT stack. Kubernetes can help organizations manage, orchestrate and secure container-based microservices.  Continue Reading

• How microservices, lambda and functional computing differ

  While the terms lambda, functional computing and microservices may get intertwined, it's important to understand what makes them unique. Here, we dive into the differences.  Continue Reading

• How to evolve architecture with a reactive programming model

  Looking to modernize your enterprise architecture? Learn why reactive programming and event-driven process management will be the foundation of this change.  Continue Reading

• Service mesh amplifies microservice management capabilities

  Kubernetes emerged to help development teams better orchestrate microservices, and now, service mesh stands to help teams more easily handle microservice integration.  Continue Reading

• How component-based software engineering spurs innovation

  Demands for digital transformation in business may ring hollow to some architects. However, componentization can play a key role in making business innovation a reality.  Continue Reading

• How the use of APIs helps spur business innovation

  Change isn't always cheap. However, by taking an API-first approach, businesses can innovate in a safe, effective and low-cost manner.  Continue Reading

• Understanding the benefits of serverless functions

  The use of serverless functions can help developers minimize the time spent managing resources by segmenting third-party dependencies. Zach Flower explains.  Continue Reading

• The pros and cons of container platforms for portability

  Container platforms enable high degrees of portability, but there are some container portability limitations related to persistent storage, different container formats and more.  Continue Reading

• In a microservices app, how many microservices are too many?

  How many microservices are optimal for your microservices app? DevOps analyst Chris Tozzi explains how to use containers, codebase analysis and other tactics to decide.  Continue Reading

• What is the future of container deployment?

  Container deployment continues to evolve with the help of VM models, microservices and DevOps. Learn how the container architecture can impact your business goals.  Continue Reading

• Comparing containers and VMs for multi-tenant apps

  Secure containers is a big concern when comparing virtual machines and containers for multi-tenant apps. Learn what each has to offer and which works best for your organization.  Continue Reading

• Troubleshooting microservices performance problems

  Get a better understanding of troubleshooting tools and techniques for managing microservices performance issues.  Continue Reading

• State and threading: Key concepts in a .NET microservices architecture

  There are a number of reasons why implementing a .NET microservices architecture presents a challenge. Tom Nolle explains how to marry .NET and microservices.  Continue Reading

• How to manage microservices with a container registry

  Container registries will help to compile and store images. Get a better understanding of popular registry products and services.  Continue Reading

• How to keep microservices performance from going south

  Microservices can streamline development, but at what cost? Kurt Marko discusses the potential performance impacts and how to implement proper microservices performance management.  Continue Reading

• Application containers offer a new approach to SOA

  Traditional SOA and containerized infrastructure share many common goals, but containers offer better efficiency and manageability. How can enterprises bring the two together?  Continue Reading

• REST vs. SOAP: Choosing the best web service

  SOAP and REST offer different methods to invoke a web service. Learn the variations between the two approaches, including integration concerns and client choices.  Continue Reading

• What alternatives to HTTP are there for microservices?

  Using HTTP as the bus for traffic between microservices can create some unwanted impacts, including more TCP/IP overhead. Mark Betz goes over some useful alternatives to HTTP.  Continue Reading

• Where do we draw the line between an iBPM and BPM platform?

  What is the difference between iBPM and BPM? Is iBPM simply an extension of the old BPM ways, or is truly something unique? Esther Shein tackles this question.  Continue Reading

• The basics of establishing a RESTful API testing program

  RESTful API testing is about establishing a culture of continuous testing and team accountability. Greg Sypolt reviews the core components of a RESTful API testing program.  Continue Reading

• How to keep things on track when building API portfolios

  As important as APIs have become, many still fail to achieve API success by not setting goals properly. Tom Nolle explains why this matters and how to manage an API portfolio.  Continue Reading

• Creating successful RESTful API design

  Successful API design requires lots of attention to detail. Take these three steps for creating RESTful API design.  Continue Reading

• Why you should reconsider using model-driven software development

  Model-driven development has been around a long time, but in today's complicated app world, it may be time to give this methodology another look. Expert Tom Nolle explains.  Continue Reading

• Six aspects of API creation that greatly impact production

  When it comes to API creation, simplicity is critical. Vivek Gupta of AnyPresence discussed the six aspects of API creation developers can address to accelerate API production.  Continue Reading

• Five tips for better API versioning and migration

  Business needs change, and that often means APIs must change along with them. Here we examine five key strategies for avoiding disaster when API changes must occur.  Continue Reading

• Consistency is critical in a business rules management system

  As much as business rules management can help an organization streamline operations, a general misunderstanding of business rules is hurting efforts. Steve Weissman explains why.  Continue Reading

• Are microservices more like SOA or MVC architecture?

  How new is the concept of microservices? Does it compare more closely with the principles of SOA or those of MVC architecture? Chris Riley examines this topic.  Continue Reading

• Why should I use a build server?

  Because apps can be built on a developer's local machine, some question the usefulness of a build server. However, Brad Irby points out that they provide some distinct advantages.  Continue Reading

• Is there a way to automate API code generation?

  As useful as APIs are, developers still struggle to create them due to lapses in documentation and specs. Brad Irby explores a tool that can help automate API code generation.  Continue Reading

• How to implement dependency injection in existing apps

  Adapting an existing app to dependency injection is worth the effort, according to an expert. Follow these tips to make the process go smoothly.  Continue Reading

• Cache networks for better mobile application performance

  Architects find they can improve mobile application performance by leveraging caching networks and new data synchronization protocols.  Continue Reading

• How to address security risks posed by middleware tools

  Middleware tools can present a huge vulnerability, enough to offset their benefits. However, with some simple steps you can protect yourself and your data.  Continue Reading

• API security more critical as componentization grows

  Securing APIs is critical as componentization grows. Expert Tom Nolle suggests that an API's security attributes are as important as functional attributes.  Continue Reading

• Web services vs. cloud services: Are they the same?

  Learn how Web services and cloud services differ, and how working together impacts business efficiency.  Continue Reading

• Where JMS 2.0 misses the mark

  JMS 2.0 added significant ease-of-use and messaging features to the popular API. Bill Claybrook looks at what's new in JMS 2.0 and what's missing.  Continue Reading

• Read and write considerations when designing APIs

  This is the third installment of a four-part series offering enterprise architects advice for designing APIs.  Continue Reading

• Updating COBOL programs: Pitfalls to avoid when going from COBOL to C

  To keep operational expenses low, keep these modernization considerations in mind when dealing with COBOL programs.  Continue Reading

• API design: How to properly build an application program interface

  Don't let your entire API project go awry. Knowing the applications well is just one way to nail the design and foster developer loyalty.  Continue Reading

• Mobile development: The pros of HTML5, hybrid, native applications

  Whether to make use of a hybrid, HTML5 or a native application depends on each specific situation.  Continue Reading

• Best practices for solutions architecture

  Solutions architecture has gained a reputation for being difficult to define. Even so, best practices unique to solutions architecture have emerged.  Continue Reading

• The impact of HTML5 on Web applications

  HTML, the HyperText Markup Language, is an essential part of the Internet experience. HTML5 is one part of what WHATWG sees as essential to the future of Web applications.  Continue Reading