Front End

Open Match Front End Edgegap's tutorial (basic)#

The Front End component of Open Match is the shield between your players and Open Match. Every player's request will pass by it. You can validate any data in this service. It is also in this component that you would validate that the data received is valid.

Prerequisites#

Go
C# (HTTP)

Install Golang 1.16^ on your computer

Create Your project#

Go
C# (HTTP)

Every Open Match service should be in its own project. Create a new folder named front-end for the OpenMatch front-end component.

In this folder, run the following command.

go mod init frontend

And create a file named main.go where the core logic of the component will be.

Create a REST API#

Go
C# (HTTP)

The first thing that we need for our front end service is a REST API. We decided to go with a REST API instead of gRPC protocol for the front end service because we thought it would be simpler

In this tutorial, we will use the framework ECHO for our REST API since it's lightweight and fast. You could use any other framework if you want.

Let's start by installing the dependencies for ECHO and Open Match

go get -u github.com/labstack/echo/v4

go get -u open-match.dev/open-match/pkg/pb

Now, in your main.go file, you can add the following code. This will create a web server that will listen on port 51504

main.go (Override All)

package main

import (
    "net/http"

    "github.com/labstack/echo/v4"
)

const (
    // Link inside kubernetes
    openMatchFrontendService = "open-match-frontend:50504"
)

func main() {
    e := echo.New()

    // How to extract IP
    e.IPExtractor = echo.ExtractIPDirect()

    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Open Match Front End Edgegap's tutorial (basic)")
    })

    e.Logger.Fatal(e.Start(":51504"))
}

You can try it by starting your app with go run ./main.go and go to http://localhost:51504/

The API should be almost done since it's been generated by the previous step! We need to change the configuration. You should change the configuration in Properties/launchSettings.json to the following.

Properties/launchSettings.json (Override All)

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:12575",
      "sslPort": 44387
    }
  },
  "profiles": {
    "front_end": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:51504",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Then, we will update Program.cs. We will add a logger, enable forwarded IP from Proxy server and add a middleware to catch unhandled exceptions.

Program.cs (Override All)

using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// Adding logging to Dependency Injection
var logger = LoggerFactory.Create(
    logBuilder => logBuilder.AddConsole(
        configuration =>
        {
            configuration.TimestampFormat = "[HH:mm:ss] ";
        })
    )
    .CreateLogger("MatchFunction");
builder.Services.AddSingleton<ILogger>(logger);

var app = builder.Build();

// Get the good IP from proxy server
app.UseForwardedHeaders();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

// Handle Exceptions
app.Use(async (context, next) =>
{
    try
    {
        await next(context);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, ex.Message);
        await context.Response.WriteAsJsonAsync(new { Message = ex.Message });
    }
});

app.MapGet("/", () => "Edgegap C# Open Match Front End!");

app.Run();

You can try it by starting your app with dotnet run and go to http://localhost:51504/

Create an Open Match ticket#

Go
C# (HTTP)

Open Match works using tickets. To let your game request a ticket, we will create an API endpoint.

Let's add a API endpoint HTTP POST on /v1/tickets. This endpoint will receive a JSON body that contains the data for the matchmaker. In this tutorial, we will keep it simple. We will receive a game mode (mode.ranked, mode.casual, mode.private). Your main function should look like this.

main.go (Replace)

func main() {
    e := echo.New()

    // How to extract IP
    e.IPExtractor = echo.ExtractIPDirect()

    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Open Match Front End Edgegap's tutorial (basic)")
    })

    // Create a ticket
    e.POST("/v1/tickets", createTicket)

    e.Logger.Fatal(e.Start(":51504"))
}

Now, we will create the function createTicket. In this function, we will extract the ticket's data from the request, send the data to Open Match Front End service via gRPC and send back the ticket that has been created.

main.go (Add to file)

// TicketRequestModel represent the model tath we should receive for our create ticket endpoint
type TicketRequestModel struct {
    Mode string
}

// Create a ticket by communicating with Open Match core Front End service
func createTicket(echoContext echo.Context) error {
    log.Println("Creating ticket...")

    // Get The player IP. This will be used later to make a call at Arbitrium (Edgegap's solution)
    echoServer := echoContext.Echo()
    request := echoContext.Request()

    playerIP := echoServer.IPExtractor(request)

    userTicketRequest := TicketRequestModel{}

    // Bind the request JSON body to our model
    err := echoContext.Bind(&userTicketRequest)

    if err != nil {
        panic("Request Payload didn't match TicketRequestModel attributes")
    }

    service, conn := getFrontendServiceClient()
    // Don't forget to close the connection to prevent any memory leak!
    defer conn.Close()

    req := &pb.CreateTicketRequest{
        Ticket: &pb.Ticket{
            SearchFields: &pb.SearchFields{
                // Tags can support multiple values but for simplicity, the demo function
                // assumes only single mode selection per Ticket.
                Tags: []string{
                    userTicketRequest.Mode,
                },
            },
            Extensions: map[string]*any.Any{
                // Adding player IP to create the game server later using Arbitrium (Edgegap's solution)
                // You can add other values in extensions. Those values will be ignored by Open Match. They are meant tu use by the developper.
                // Find all valid type here: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf
                "playerIp": {
                    TypeUrl: "type.googleapis.com/google.protobuf.StringValue",
                    Value:   []byte(playerIP),
                },
            },
        },
    }

    ticket, err := service.CreateTicket(context.Background(), req)

    if err != nil {
        log.Printf("Was not able to create a ticket, err: %s\n", err.Error())
    }

    return echoContext.JSON(http.StatusOK, ticket)
}

// Get an object that can communicate with Open Match Front End service.
func getFrontendServiceClient() (pb.FrontendServiceClient, *grpc.ClientConn) {
    conn, err := grpc.Dial(
        openMatchFrontendService, grpc.WithInsecure(),
    )

    if err != nil {
        panic(fmt.Sprintf("Could not dial Open Match Frontend service via gRPC, err: %v", err.Error()))
    }

    return pb.NewFrontendServiceClient(conn), conn
}

Don't forget to change your import!

main.go (Replace)

import (
    "context"
    "fmt"
    "log"
    "net/http"

    "github.com/golang/protobuf/ptypes/any"
    "github.com/labstack/echo/v4"
    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

Now we can test our new endpoint. Let's start our app and try it.

Warning :

At this point, if you send a request to create a ticket, you should have this error on the server side.

Was not able to create a ticket, err: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing dial tcp: lookup open-match-frontend: no such host"

This means that your application was not able to contact the OpenMatch Front End service. It's normal. The service is not exposed outside of the Kubernetes cluster. If you want to try it now, you can expose the service and change the variable openMatchFrontendService by 127.0.0.1:50504. Keep in mind that this is TEMPORARY.

To expose the service run

kubectl port-forward --namespace open-match service/open-match-frontend 50504:50504

Restart your app.

Now, if you send a request, everything should be fine, and your ticket should be created.

go run ./main.go

To test this functionality, make a POST request to http://localhost:51504/v1/tickets with the following command.

Bash
Powershell

curl -X POST -H "Content-Type: application/json" -d '{"mode": "mode.casual"}' 127.0.0.1:51504/v1/tickets

Open Match works using tickets. To let your game request a ticket, we will create an API endpoint.

Program.cs (Override All)

using front_end;
using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// Adding logging to Dependency Injection
var logger = LoggerFactory.Create(
    logBuilder => logBuilder.AddConsole(
        configuration =>
        {
            configuration.TimestampFormat = "[HH:mm:ss] ";
        })
    )
    .CreateLogger("MatchFunction");
builder.Services.AddSingleton<ILogger>(logger);

var app = builder.Build();

// Get the good IP from proxy server
app.UseForwardedHeaders();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

// Handle Exceptions
app.Use(async (context, next) =>
{
    try
    {
        await next(context);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, ex.Message);
        await context.Response.WriteAsJsonAsync(new { Message = ex.Message });
    }
});

app.MapGet("/", () => "Edgegap C# Open Match Front End!");

// Handle POST requests to create a ticket
app.MapPost("/v1/tickets", CreateTicket.Handle);

app.Run();

Now, we will create a file named Models.cs. This file will contain all the models used for HTTP calls.

Models.cs (Override All)

using System.Collections.Generic;
using System.Text.Json.Serialization;

namespace front_end
{
    // Represent the model tath we should receive for our create ticket endpoint
    public struct CreateTicketPayload
    {
        [JsonPropertyName("mode")]
        public string Mode { get; set; }
    }

    // Based On OpenMatchCreateTicketRequest in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
    public struct OpenMatchCreateTicketRequest
    {
        [JsonPropertyName("ticket")]
        public OpenMatchTicket Ticket { get; set; }
    }

    // Based On OpenMatchTicket in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
    public struct OpenMatchTicket
    {
        [JsonPropertyName("id")]
        public string Id { get; set; }
        [JsonPropertyName("search_fields")]
        public OpenMatchSearchFields SearchFields { get; set; }
        [JsonPropertyName("extensions")]
        public Dictionary<string, ProtobufAny> Extensions { get; set; }
    }

    // Based On OpenMatchSearchFields in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
    public struct OpenMatchSearchFields
    {
        [JsonPropertyName("tags")]
        public string[] Tags { get; set; }
    }

    // Based On ProtobufAny in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
    public struct ProtobufAny
    {
        [JsonPropertyName("@type")]
        public string TypeUrl { get; set; }
        [JsonPropertyName("value")]
        public byte[] Value { get; set; }
    }
}

Now, we will create a file named Core.cs. This file will contain all the classes that have logic inside.

In Core.cs, let's create a class named Constant. In this class, we will store all the constants for our front end.

In Core.cs, let's create a class named CreateTicket with a function Handle. In this function, we will extract the ticket's data from the request, send the data to Open Match Front End service via HTTP and send back the ticket that has been created.

Core.cs (Override All)

using System.Net;
using System.Text.Json.Serialization;

namespace front_end
{
    // All the constants used in the program
    public static class Constant
    {
        public static string OpenMatchFrontendService => "open-match-frontend:51504";
    }

    public class CreateTicket
    {
        public static async Task Handle(HttpContext context)
        {
            Console.WriteLine("Creating ticket...");

            // Get The player IP. This will be used later to make a call at Arbitrium (Edgegap's solution)
            IPAddress? playerIP = GetIPAddress(context)?.MapToIPv4();

            // Get the payload of the request
            CreateTicketPayload payload = await context.Request.ReadFromJsonAsync<CreateTicketPayload>();

            string response = await CreateTicketToOpenMatch(payload.Mode, playerIP?.ToString() ?? "0.0.0.0");

            context.Response.ContentType = "application/json";
            await context.Response.WriteAsync(response);
        }

        private static IPAddress? GetIPAddress(HttpContext context) => context.Connection.RemoteIpAddress;

        private static async Task<string> CreateTicketToOpenMatch(string mode, string playerIP)
        {
            HttpClient client = new HttpClient();

            byte[] playerIPBytes = System.Text.Encoding.UTF8.GetBytes(playerIP);

            // Creating the payload
            OpenMatchCreateTicketRequest body = new OpenMatchCreateTicketRequest
            {
                Ticket = new OpenMatchTicket
                {
                    SearchFields = new OpenMatchSearchFields { Tags = new string[] { mode } },
                    Extensions = new Dictionary<string, ProtobufAny>
                        {
                            {
                                "playerIp",
                                new ProtobufAny
                                {
                                    TypeUrl = "type.googleapis.com/google.protobuf.StringValue",
                                    Value = playerIPBytes
                                }
                            }
                        }
                }
            };

            // Sending the request to Open Match Front End
            HttpResponseMessage response = await client.PostAsJsonAsync(
                $"http://{Constant.OpenMatchFrontendService}/v1/frontendservice/tickets",
                body
            );

            // Check if we were able to create the ticket
            if (response.StatusCode != HttpStatusCode.OK)
            {
                string msg = $"ERROR - Was not able to create a ticket: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}";
                Console.WriteLine(msg);
                throw new Exception(msg);
            }

            return await response.Content.ReadAsStringAsync();
        }
    }
}

Now we can test our new endpoint. Let's start our app and try it.

Warning :

At this point, if you send a request to create a ticket, you should have this error on the server side.

No such host is known. (open-match-frontend:51504) System.Net.Http.HttpRequestException: No such host is known. (open-match-frontend:51504) ...

This means that your application was not able to contact the OpenMatch Front End service. It's normal. The service is not exposed outside of the Kubernetes cluster.

dotnet run

To test this functionality, make a POST request to http://localhost:51504/v1/tickets with the following command.

Bash
Powershell

curl -X POST -H "Content-Type: application/json" -d '{"mode": "mode.casual"}' 127.0.0.1:51504/v1/tickets

Get a ticket#

Go
C# (HTTP)

Let's add a API endpoint HTTP GET on /v1/tickets/:ticketId. This endpoint will return the data about a ticket with a given ID. Your main function should look like this.

main.go (Replace)

func main() {
    e := echo.New()

    // How to extract IP
    e.IPExtractor = echo.ExtractIPDirect()

    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Open Match Front End Edgegap's tutorial (basic)")
    })

    // Create a ticket
    e.POST("/v1/tickets", createTicket)

    // Get a ticket
    e.GET("/v1/tickets/:ticketId", getTicket)

    e.Logger.Fatal(e.Start(":51504"))
}

Now, we will create the function getTicket. In this function, we will fetch the ticket from OpenMatch Front End service via gRPC and send it back to the client.

main.go (Add to file)

func getTicket(echoContext echo.Context) error {
    ticketID := echoContext.Param("ticketId")

    service, conn := getFrontendServiceClient()
    // Don't forget to close the connection to prevent any memory leak!
    defer conn.Close()

    req := &pb.GetTicketRequest{
        TicketId: ticketID,
    }

    ticket, err := service.GetTicket(context.Background(), req)

    if err != nil {
        log.Printf("Was not able to get a ticket, err: %s\n", err.Error())
        return echo.NewHTTPError(http.StatusNotFound, "Resource not found")
    }

    return echoContext.JSON(http.StatusOK, ticket)
}

Now we can test our new endpoint. Let's start our app try it.

Warning : At this point, if you send a request to get a ticket, you should have this error on the server-side.

Was not able to get a ticket, err: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing dial tcp: lookup open-match-frontend: no such host"

To expose the service run

kubectl port-forward --namespace open-match service/open-match-frontend 50504:50504

Restart your app.

Now, if you send a request, everything should be fine, and your ticket should be returned if it exists.

go run ./main.go

To test this functionality, make a GET request to http://localhostL51504/v1/tickets/<ticket id>, changing <ticket id> for an ID.

Bash
Powershell

curl -X GET 127.0.0.1:51504/v1/tickets/[TICKET_ID]

Let's add a API endpoint HTTP GET on /v1/tickets/:ticketId. This endpoint will return the data about a ticket with a given ID. Your main function should look like this.

Program.cs (Override All)

using front_end;
using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// Adding logging to Dependency Injection
var logger = LoggerFactory.Create(
    logBuilder => logBuilder.AddConsole(
        configuration =>
        {
            configuration.TimestampFormat = "[HH:mm:ss] ";
        })
    )
    .CreateLogger("MatchFunction");
builder.Services.AddSingleton<ILogger>(logger);

var app = builder.Build();

// Get the good IP from proxy server
app.UseForwardedHeaders();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

// Handle Exceptions
app.Use(async (context, next) =>
{
    try
    {
        await next(context);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, ex.Message);
        await context.Response.WriteAsJsonAsync(new { Message = ex.Message });
    }
});

app.MapGet("/", () => "Edgegap C# Open Match Front End!");

// Handle POST requests to create a ticket
app.MapPost("/v1/tickets", CreateTicket.Handle);

// Handle GET requests to get a ticket
app.MapGet("/v1/tickets/{ticketId}", GetTicket.Handle);


app.Run();

In Core.cs, let's create a class named GetTicket with a function Handle. In this function, we will fetch the ticket from OpenMatch Front End service via HTTP and send it back to the client.

Core.cs (Add to namespace front_end)

public class GetTicket
{
    public static async Task Handle(HttpContext context, string ticketId)
    {
        HttpClient client = new HttpClient();

        // Sending the request to Open Match Front End
        HttpResponseMessage response = await client.GetAsync($"http://{Constant.OpenMatchFrontendService}/v1/frontendservice/tickets/{ticketId}");

        // Check if we were able to Get the ticket
        if (response.StatusCode != HttpStatusCode.OK)
        {
            string msg = $"ERROR - Was not able to get ticket {ticketId}: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}";
            Console.WriteLine(msg);
            throw new Exception(msg);
        }

        string responseContent = await response.Content.ReadAsStringAsync();

        context.Response.ContentType = "application/json";
        await context.Response.WriteAsync(responseContent);
    }
}

Now we can test our new endpoint. Let's start our app and try it.

Warning :

At this point, if you send a request to create a ticket, you should have this error on the server side.

No such host is known. (open-match-frontend:51504) System.Net.Http.HttpRequestException: No such host is known. (open-match-frontend:51504) ...

This means that your application was not able to contact the OpenMatch Front End service. It's normal. The service is not exposed outside of the Kubernetes cluster.

dotnet run

To test this functionality, make a GET request to http://localhost:51504/v1/tickets/<ticket id> changing <ticket id> for an ID.

Bash
Powershell

curl -X GET 127.0.0.1:51504/v1/tickets/[TICKET_ID]

Delete a ticket#

Go
C# (HTTP)

Let's add a API endpoint HTTP DELETE on /v1/tickets/:ticketId. This endpoint will delete the ticket if it exists. Your main function should look like this.

main.go (Replace)

func main() {
    e := echo.New()

    // How to extract IP
    e.IPExtractor = echo.ExtractIPDirect()

    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Open Match Front End Edgegap's tutorial (basic)")
    })

    // Create a ticket
    e.POST("/v1/tickets", createTicket)

    // Get a ticket
    e.GET("/v1/tickets/:ticketId", getTicket)

    // Delete a ticket
    e.DELETE("/v1/tickets/:ticketId", deleteTicket)

    e.Logger.Fatal(e.Start(":51504"))
}

Now, we will create the function deleteTicket. In this function, we will delete the ticket from the OpenMatch Front End service via gRPC and send it back to the client.

main.go (Add to namespace file)

func deleteTicket(echoContext echo.Context) error {
    ticketID := echoContext.Param("ticketId")

    service, conn := getFrontendServiceClient()
    // Don't forget to close the connection to prevent any memory leak!
    defer conn.Close()

    req := &pb.DeleteTicketRequest{
        TicketId: ticketID,
    }

    _, err := service.DeleteTicket(context.Background(), req)

    if err != nil {
        fmt.Printf("Was not able to delete a ticket, err: %s\n", err.Error())
        return echo.NewHTTPError(http.StatusNotFound, "Resource not found")
    }

    return echoContext.JSON(http.StatusOK, pb.Ticket{Id: ticketID})
}

Now we can test our new endpoint. Let's start our app try it.

Warning : At this point, if you send a request to delete a ticket, you should have this error on the server-side.

Was not able to delete a ticket, err: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing dial tcp: lookup open-match-frontend: no such host"

To expose the service run

kubectl port-forward --namespace open-match service/open-match-frontend 50504:50504

Restart your app.

Now, if you send a request, everything should be fine and your ticket should be deleted if it exists.

go run ./main.go

To test this functionality, make a DELETE request to http://localhost:51504/v1/tickets/<ticket id> changing <ticket id> for an ID.

Bash
Powershell

curl -X DELETE 127.0.0.1:51504/v1/tickets/[TICKET_ID]

Let's add a API endpoint HTTP DELETE on /v1/tickets/:ticketId. This endpoint will delete the ticket if it exists. Your main function should look like this.

Program.cs (Override All)

using front_end;
using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// Adding logging to Dependency Injection
var logger = LoggerFactory.Create(
    logBuilder => logBuilder.AddConsole(
        configuration =>
        {
            configuration.TimestampFormat = "[HH:mm:ss] ";
        })
    )
    .CreateLogger("MatchFunction");
builder.Services.AddSingleton<ILogger>(logger);

var app = builder.Build();

// Get the good IP from proxy server
app.UseForwardedHeaders();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

// Handle Exceptions
app.Use(async (context, next) =>
{
    try
    {
        await next(context);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, ex.Message);
        await context.Response.WriteAsJsonAsync(new { Message = ex.Message });
    }
});

app.MapGet("/", () => "Edgegap C# Open Match Front End!");

// Handle POST requests to create a ticket
app.MapPost("/v1/tickets", CreateTicket.Handle);

// Handle GET requests to get a ticket
app.MapGet("/v1/tickets/{ticketId}", GetTicket.Handle);

// Handle DELETE requests to delete a ticket
app.MapDelete("/v1/tickets/{ticketId}", DeleteTicket.Handle);


app.Run();

In Core.cs, let's create a class named DeleteTicket with a function Handle. In this function, we will delete the ticket from OpenMatch Front End service via HTTP and send it back to the client.

Core.cs (Add to namespace front_end)

public class DeleteTicket
{
    public static async Task Handle(HttpContext context, string ticketId)
    {
        HttpClient client = new HttpClient();

        // Sending the request to Open Match Front End
        HttpResponseMessage response = await client.DeleteAsync($"http://{Constant.OpenMatchFrontendService}/v1/frontendservice/tickets/{ticketId}");

        // Check if we were able to Get the ticket
        if (response.StatusCode != HttpStatusCode.OK)
        {
            string msg = $"ERROR - Was not able to delete ticket {ticketId}: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}";
            Console.WriteLine(msg);
            throw new Exception(msg);
        }

        context.Response.ContentType = "application/json";
        await context.Response.WriteAsJsonAsync(new { Id = ticketId });
    }
}

Now we can test our new endpoint. Let's start our app and try it.

Warning :

At this point, if you send a request to create a ticket, you should have this error on the server side.

No such host is known. (open-match-frontend:51504) System.Net.Http.HttpRequestException: No such host is known. (open-match-frontend:51504) ...

This means that your application was not able to contact the OpenMatch Front End service. It's normal. The service is not exposed outside of the Kubernetes cluster.

dotnet run

To test this functionality, make a DELETE request to http://localhost:51504/v1/tickets/<ticket id> changing <ticket id> for an ID.

Bash
Powershell

curl -X DELETE 127.0.0.1:51504/v1/tickets/[TICKET_ID]

Containerize your service#

Go
C# (HTTP)

Before the Containerization, don't forget to change back openMatchFrontendService to open-match-frontend:50504 if you changed it.

Containerization is powerful. You can learn more about it on Edgegap's documentation or Docker. Our container will use golang:1.16 for its base image.

Create a file named Dockerfile and write this inside.

FROM golang:1.16

COPY . /go/src/app
WORKDIR /go/src/app

RUN go get -d -v /go/src/app
RUN go install -v /go/src/app

WORKDIR /go/bin

CMD ["frontend"]

You can now build your image using.

docker build -t edgegap-om-tuto-frontend:tuto .

You can run it using this command, but without all the other services, it will not work.

docker run -it -p 51504:51504 --name om-tuto-frontend edgegap-om-tuto-frontend:tuto

Conclusion#

You now have a basic Open Match Front End REST API service that can be called from your game. This is not production-ready. However, you should be able to grasp the basics of Open Match Front End. You also created a Docker image that can be used later.