GitHub Is Your Asynchronous Microservice Showroom
GitHub Is Your Asynchronous Microservice Showroom
A GitHub repo is more than a place to store your microservices, it should show potential users what those services do and how well they do it.
Join the DZone community and get the full member experience.Join For Free
When you spend time looking at a lot of microservices, across many different organizations, you really begin to get a feel for the ones who have owners/stewards that are thinking about the bigger picture. When people are just focused on what the service does, and not actually how the service will be used, the GitHub repos tend to be cryptic, out of sync, and don’t really tell a story about what is happening. GitHub is often just seen as a vehicle for the code to participate in a pipeline, and not about speaking to the rest of the humans and systems involved in the overall microservices concert that is occurring.
GitHub Is Your Showroom
Each microservices is self-contained within a GitHub repository, making it the showcase for the service. Remember, the service isn’t just the code, and other artifacts buried away in the folders for nobody to understand, unless you understand how to operate the service or continuously deploy the code. It is a service. The service is part of a larger suite of services and is meant to be understood and reusable by other human beings in the future, potentially long after you are gone, and aren’t present to give a 15-minute presentation in a meeting. GitHub is your asynchronous microservices showroom, where ANYONE should be able to land and understand what is happening.
README Is Your Menu
The README is the centerpiece of your showroom. Anyone should be able to land on the README for your service, and immediately get up to speed on what a service does, and where it is in its lifecycle. README should not be written for other developers, it should be written for other humans. It should have a title, and short, concise, plain language description of what a service does, as well as any other relevant details about what a service delivers. The README for each service should be a snapshot of a service at any point in time, demonstrating what it delivers currently, what the roadmap contains, and the entire history of a service throughout its lifecycle. Every artifact, documentation, and relevant element of a service should be available and linked to via the README for a service.
An OpenAPI Contract
Your OpenAPI (fka Swagger) file is the central contract for your service, and the latest version(s) should be linked to prominently from the README for your service. This JSON or YAML definition isn’t just some output as exhaust from your code, it is the contract that defines the inputs and outputs of your service. This contract will be used to generate code, mocks, sample data, tests, documentation, and drive API governance and orchestration across not just your individual service, but potentially hundreds or thousands of services. An update to date, static representation of your services API contract should always be prominently featured off the README for a service, and ideally located in a consistent folder across services, as services architects, designers, coaches, and governance people will potentially be looking at many different OpenAPI definitions at any given moment.
GitHub issues aren’t just for issues. It is a robust, taggable, conversational thread around each individual service. GitHub issues should be the self-contained conversation that occurs throughout the lifecycle of a service, providing details of what has happened, what the current issues are, and what the future roadmap will hold. GitHub issues are designed to help organize a robust amount of conversational threads and allow for exploration and organization using tags, allowing any human to get up to speed quickly on what is going on. GitHub issues should be an active journal for the work being done on a service, through a monologue by the service owner/steward, and act as the feedback loop with ALL OTHER stakeholders around a service. GitHub issues for each service will be how the anthropologists decipher the work you did long after you are gone, and should articulate the entire life of each individual service.
Services Working in Concert
Each microservice is a self-contained unit of value in a larger orchestra. Each microservice should do one thing and do it well. The state of each services GitHub repository, README, OpenAPI contract, and the feedback loop around it will impact the overall production. While a service may be delivered to meet a specific application need in its early moments, the README, OpenAPI contract, and feedback loop should attract and speak to any potential future application. A service should be able to reused, and remixed by any application developer building internal, partner, or someday public applications. Not everyone landing on your README will have been in the meetings where you presented your service. GitHub is your service’s showroom, and where you will be making your first, and ongoing impression on other developers, as well as executives who are poking around.
Leading Through API Governance
Your GitHub repo, README, and OpenAPI contract is being used by overall microservices governance operations to understand how you are designing your services, crafting your schema, and delivering your service. Without an OpenAPI, and README, your service does nothing in the context of API governance, and feeding into the bigger picture, and helping define overall governance. Governance isn’t scripture coming off the mountain and telling you how to operate, it is gathered, extracted, and organized from existing best practices, and leadership across teams. Sure, we bring in outside leadership to help round off the governance guidance, but without a README, OpenAPI, and active feedback loop around each service, your service isn’t participating in the governance lifecycle. It is just an island, doing one thing, and nobody will ever know if it is doing it well.
Making Your GitHub Presence Count
Hopefully, this post helps you see your own microservice GitHub repository through an external lens. Hopefully, it will help you shift from GitHub being just about code, for coders, to something that is part of a larger conversation. If you care about doing microservices well, and you care about the role your service will play in the larger application production, you should be investing in your GitHub repository being the showroom for your service. Remember, this is a service. Not in a technical sense, but in a business sense. Think about what good service is to you. Think about the services you use as a human being each day. How you like being treated, and how informed you like to be about the service details, pricing, and benefits. Now, visit the GitHub repositories for your services, think about the people who will be consuming them in their applications. Does it meet your expectations for a quality level of service? Will someone brand new land on your repo and understand what your service does? Does your microservice do one thing, and does it do it well?
Published at DZone with permission of Kin Lane , DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.