Docs
START HERE
Overview
Welcome to the Dokkimi user documentation!
Dokkimi is an on-demand, no-code testing platform designed to streamline your micro-services testing process. With Dokkimi, your teams can keep running like a finely tuned machine by easily configuring and executing tests for your micro-services in Docker containers.
Unlike traditional testing solutions, Dokkimi allows you to change tests and parameters anytime you see fit, even while your clusters are running. This flexibility enables you to optimize your testing process without any interruptions, saving you time and resources.
In this user documentation, you will find detailed instructions on how to use Dokkimi to test your micro-services. You will learn how to create clusters, configure tests, and execute them. You will also find helpful tips on how to troubleshoot common issues that may arise during the testing process.
At Dokkimi, we understand that testing can be a complex and time-consuming process. That’s why we designed our platform to be user-friendly and intuitive, so you can focus on what matters most – delivering high-quality micro-services.
Thank you for choosing Dokkimi as your micro-services testing solution. Let’s get started!
Getting Started with Dokkimi
To start using Dokkimi, follow these simple steps:
Sign up for an account: The first step to using Dokkimi is to sign up for an account on our website. This will give you access to all the features and functionalities of our platform. Once you have signed up, you will receive an email with instructions on how to activate your account.
Create a Private Access Token: Once you have signed up, you will need to create a private access token for your sandbox environment. This can be done in the Settings section of your account dashboard. You can access and reference these tokens at the time of running your sandbox environments.
Link your Database: Dokkimi allows you to link your database by adding a database file. This will enable you to manage your database and execute queries against it.
Link to your Docker repository: To use Dokkimi, you need to link your private or a public docker repository. This can be done in the Docker section of your sandbox environment by providing the necessary information.
Create and manage your Sandbox Environments: With Dokkimi, you can create and manage sandbox environments for testing your microservices. You can start and stop your sandbox environments on-demand, switch between environments, and delete them when you no longer need them.
Using the Canvas
Once you have set up your sandbox environment, you can start using the Dokkimi canvas to manage your services, databases, HTTP requests, mock endpoints, and database queries. The canvas provides a visual interface for managing your microservices and makes it easy to test, configure, and modify your services. You can drag and drop elements onto the canvas, configure them as needed, and execute tests with ease.
Starting and Stopping your Sandbox on Demand
To start and stop your sandbox environment, simply navigate to the sandbox environment panel and click on the “Start” or “Stop” button.
Deleting your Sandbox
To delete your sandbox environment, navigate to the sandbox environment panel and click on the “Delete” button. This will delete all the data associated with your sandbox environment, so be sure to back up any important data before deleting your environment.
Switching between Sandbox Environments
If you have multiple sandbox environments, you can switch between them by navigating to the sandbox environment panel and selecting the environment you want to switch to. This makes it easy to test different configurations and parameters for your microservices.
We hope this guide helps you get started with Dokkimi. If you have any questions or need assistance, please don’t hesitate to contact our support team.
Using the Canvas
Services
In Dokkimi, a service is a microservice that is deployed as a Docker container. Services are the building blocks of microservices architecture, allowing you to break down complex applications into smaller, more manageable components.
With Dokkimi’s service management tools, you can easily create, deploy, and manage your microservices, allowing you to test and iterate on your applications quickly and efficiently. By linking your services to databases, HTTP requests, and mock endpoints, you can create complex testing scenarios that simulate real-world usage of your microservices.
Services can be customized to fit your specific needs, with options for adding environment variables, custom health checks, and more. With Dokkimi’s service management tools, you can create and manage the services you need to build robust and scalable microservices applications.
Please follow the below steps to get started with creating a service on Dokkimi:
Connect your docker image: To create a new service, you will need to connect it with your Docker image. This can be done by navigating to the Services section of your toolbox and clicking on “Add Service”. You will then be prompted to enter the name of your service and the Docker image domain and port.
Add a custom health check: In addition to connecting your Docker image, you can also add an optional custom health check string to ensure that your service is functioning properly. This can be done by selecting the “Add Health Check” option and entering your custom health check string.
Select your Private Access Key: To ensure secure access to your service, you can select one of your Private Access Keys to use with your service. This can be done by selecting the “Access Key” option and choosing the Private Access Key that you want to use.
Add environment variables: Finally, you can add any necessary environment variables to your service by selecting the “Environment Variables” option and entering your key and value pairs.
Once you have completed these steps, your new service will be created and you can start using it to test your micro-services.
Database
A database is a crucial component in microservices architecture, as it provides persistent storage for data used by the microservices. In Dokkimi, you can create and manage databases easily, allowing you to set up and test your microservices without having to worry about data management.
With the ability to create new databases, you can quickly and easily set up the required data structure for your microservices to interact with. This allows you to test and debug your microservices without worrying about corrupting or losing important data.
Using a database in conjunction with Dokkimi’s other testing features allows you to comprehensively test your microservices in a controlled environment, ensuring that they perform as expected and that your team can identify and fix any issues before they make their way into production.
Here are the steps to getting started with databases in Dokkimi:
Select “New Database” from the toolbox: To create a new database, navigate to the Databases section of your toolbox and click on “New Database”.
Give your database a name: Enter a name for your new database that will help you identify it later.
Select the database type: You will need to select a database type, which can be either Postgres or MySQL, depending on your needs.
Choose a database file init type: Finally, you will need to choose the database file init type from the uploaded database files in your settings section. This will allow you to initialize your new database with the data and schema from your existing database.
Once you have completed these steps, your new database will be created and connected to your sandbox environment
HTTP Requests
An HTTP request is a message sent by a client (such as a web browser or mobile app) to a server, asking for a resource to be provided. The request contains a URL, along with optional headers and a body containing any additional data that needs to be sent to the server.
HTTP requests are the foundation of the World Wide Web and are used to retrieve web pages, images, videos, and other resources from servers. They are also used for various other purposes, such as submitting form data, logging in to a website, and interacting with web APIs.
In software development, HTTP requests are often used to create and test APIs. Developers can send requests to a server and inspect the responses to ensure that the API is working correctly and returning the expected data. HTTP requests are also used in automated testing, where scripts are used to send requests and verify the responses, helping to ensure that applications are functioning correctly.
Dokkimi provides a user-friendly canvas interface that allows developers to create and manage HTTP requests easily. This makes it simple to test and debug microservices quickly, ensuring that they are functioning correctly and meeting the needs of their users. With Dokkimi, developers can streamline the development process and focus on delivering high-quality microservices.
Select “HTTP Request” from the toolbox: To create a new HTTP request, navigate to the HTTP Requests section of your sandbox environment and click on “HTTP Request” from the toolbox.
Select the type of HTTP request: You will need to select the type of HTTP request that you want to create, which can be any of the following: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS, PURGE, LINK, or UNLINK.
Select the target service: Next, you will need to select the target service that you want to send the HTTP request to. This can be any of the existing services that you have created in your sandbox environment.
Enter the HTTP request path: You will then need to enter the path for your HTTP request, which is the URL endpoint that you want to access on the target service.
Enter your request headers: If your HTTP request requires any headers, you can enter them in the “Request Headers” section. This may include authentication headers, content-type headers, or any other headers that are required by the target service.
Enter your request body: Finally, you can enter the body of your HTTP request in the “Request Body” section. This may include any data that you need to send to the target service as part of your request.
Once you have completed these steps, your new HTTP request will be created
Mock Endpoint
A mock endpoint is a simulated version of a real API endpoint that returns pre-configured responses based on the input it receives. It is essentially a “fake” version of a service that mimics the behavior of the real service in order to test how other systems will interact with it.
Mock endpoints are commonly used in software development and testing to help identify and resolve issues with APIs before they are deployed to production. By simulating the behavior of an API endpoint, developers can test their applications against it to ensure that they are working correctly and handling errors properly.
Mock endpoints can also be useful in situations where the real API is unavailable or under development. They allow developers to continue working on their applications without being blocked by unavailable or unstable services.
In Dokkimi, creating a mock endpoint is a simple process that can be done through the user-friendly canvas interface. Once created, mock endpoints can be used to test and debug your micro-services, helping to ensure that they are functioning correctly and meeting the needs of your users.
Select “Mock Endpoint” from the toolbox: To create a new mock endpoint, navigate to the Mock Endpoint section of your toolbox and click on “Mock Endpoint”.
Select the type of request: You will need to select the type of request that you want to mock, which can be any of the following: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS, PURGE, LINK, or UNLINK.
Add optional delay and response status: You can add an optional delay in milliseconds to simulate network latency, and set an optional response status code.
Add the origin: You can specify the origin of the mock endpoint. If you set it to “*”, any origin will be accepted.
Add the target URL: You will need to specify the target URL that the mock endpoint will intercept and return a response for.
Add the request path: You will need to enter the path for your mock endpoint request, which is the URL endpoint that you want to mock.
Enter your request headers: If your mock endpoint request requires any headers, you can enter them in the “Request Headers” section. This may include authentication headers, content-type headers, or any other headers that are required by the target service.
Enter your request body: Finally, you can enter the body of your mock endpoint request in the “Request Body” section. This may include any data that you need to send to the target service as part of your mock endpoint request.
Once you have completed these steps, your new mock endpoint will be created and you can use it to test the functionality of your micro-services
Database Query
A database query is a request made to a database management system (DBMS) for specific information from the database. In Dokkimi, a database query can be used to test the functionality and performance of your microservices by simulating real-world database interactions.
With Dokkimi’s database query tool, you can easily create and execute queries against your linked databases, allowing you to test the accuracy and efficiency of your database interactions. You can use queries to test everything from simple data retrieval to complex data manipulations, helping you identify issues and optimize your microservices for peak performance.
Navigate to your toolbox and select “Database query”.
Select your target database from the databases added: Select the database that you want to run the query on from the list of databases that you have added to your Dokkimi account.
Add your query in the query format for your database type: Depending on the type of database you are using, you will need to add your query in the correct query format. For example, if you are using a MySQL database, you will need to write your query in SQL format. If you are using a PostgreSQL database, you will need to write your query in PostgreSQL format. Once you have added your query, click on “Run Query” to execute the query.
View the query results: Once you have executed the query, the results will be displayed in the response section.
Limitations for Beta users
As a beta user of Dokkimi, you may experience some limitations and temporary restrictions. These are in place to ensure a smooth and reliable experience for all users while we work to improve the platform. Here are some key points to keep in mind:
Limited access to public resources: As a beta user, you may not be able to access all the features and functionality that are available to full users. However, we are continually working to improve the platform and will keep you updated on any new features that become available.
Possible bugs or issues: Beta users may experience bugs or issues with the platform that are still being worked out. We appreciate your patience and understanding as we work to improve Dokkimi for all users.
Temporary limitations: These limitations are temporary and are in place to ensure a smooth and reliable experience for all users. We will keep beta users updated on any changes and new features that become available.
If you have any questions or concerns about the limitations for beta users, please don’t hesitate to contact our support team for assistance. We appreciate your feedback and look forward to working with you to make Dokkimi the best micro-services testing platform available.