### Run Node.js Example Gameserver via npm

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Starts the node.js example gameserver using npm, assuming all dependencies are installed.

```npm
npm start
```

--------------------------------

### First Example Output of GameServer States

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Illustrates a typical tabular output from the `kubectl get gs` command, displaying a list of GameServers with their names, current states (e.g., `Ready`, `Allocated`), network addresses, ports, nodes, and age. This specific example shows one `Allocated` server among several `Ready` ones.

```text
NAME                             STATE       ADDRESS           PORT   NODE      AGE
simple-game-server-sdhzn-kcmh6   Ready       192.168.122.205   7191   minikube  52m
simple-game-server-sdhzn-pdpk5   Ready       192.168.122.205   7752   minikube  53m
simple-game-server-sdhzn-r4d6x   Allocated   192.168.122.205   7623   minikube  52m
simple-game-server-sdhzn-wng5k   Ready       192.168.122.205   7709   minikube  53m
simple-game-server-sdhzn-wnhsw   Ready       192.168.122.205   7478   minikube  52m
```

--------------------------------

### Second Example Output of GameServer States

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Provides another example of the `kubectl get gs` command's output, similar in format to the first but with different GameServer names and details. This further demonstrates how to interpret the state of game servers within a fleet, showing another instance of an `Allocated` server.

```text
NAME                             STATE       ADDRESS          PORT   NODE        AGE
simple-game-server-tfqn7-c9tqz   Ready       192.168.39.150   7136   minikube    52m
simple-game-server-tfqn7-g8fhq   Allocated   192.168.39.150   7148   minikube    53m
simple-game-server-tfqn7-p8wnl   Ready       192.168.39.150   7453   minikube    52m
simple-game-server-tfqn7-t6bwp   Ready       192.168.39.150   7228   minikube    53m
simple-game-server-tfqn7-wkb7b   Ready       192.168.39.150   7226   minikube    52m
```

--------------------------------

### Start Local Agones SDK-Server for Testing

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Starts a local instance of the Agones SDK-server for testing the gameserver example. The server will run for 120 seconds and enable specific tests.

```bash
cd ../../build; make run-sdk-conformance-local TIMEOUT=120 TESTS=ready,watch,health,gameserver
```

--------------------------------

### Install Specific Google Cloud Go Package

Source: https://github.com/googleforgames/agones/blob/main/vendor/cloud.google.com/go/README.md

This example shows how to use the `go get` command to install a particular Google Cloud Go package, such as `firestore`. Users should replace the placeholder with the specific package they intend to use for their project.

```Bash
go get cloud.google.com/go/firestore # Replace with the package you want to use.
```

--------------------------------

### Build Agones Simple Game Server Binary

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/edit-first-gameserver-go.md

Builds the Go server binary for the simple-game-server example, including necessary environment variables for cross-compilation to Linux AMD64 for Docker.

```Bash
go get agones.dev/agones/pkg/sdk
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o bin/server -a -v main.go
```

--------------------------------

### Install Viper Go Configuration Library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/spf13/viper/README.md

This snippet provides the command-line instruction to install the Viper library for Go projects. It uses the standard 'go get' command to fetch and install the Viper package from its GitHub repository, making it available for use in your Go applications.

```console
go get github.com/spf13/viper
```

--------------------------------

### Monitor Agones Game Server Readiness

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleetautoscaler.md

Command to continuously observe the state of game server instances using `watch kubectl get gs` and an example output showing 5 ready server instances after autoscaling adjustments.

```shell
watch kubectl get gs
NAME                             STATE     ADDRESS        PORT    NODE         AGE
simple-game-server-mzhrl-7jpkp   Ready     10.30.64.100   7019    minikube     5m
simple-game-server-mzhrl-czt8v   Ready     10.30.64.168   7556    minikube     5m
simple-game-server-mzhrl-k6jg5   Ready     10.30.64.100   7243    minikube     5m
simple-game-server-mzhrl-nb8h2   Ready     10.30.64.168   7357    minikube     5m
simple-game-server-mzhrl-qspb6   Ready     10.30.64.99    7859    minikube     5m
simple-game-server-mzhrl-zg9rq   Ready     10.30.64.99    7745    minikube     5m
```

--------------------------------

### Install and Run Local Go Documentation Site

Source: https://github.com/googleforgames/agones/blob/main/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md

Provides shell commands to install the `pkgsite` tool and run a local Go documentation server, useful for reviewing Go Doc Comments and Examples.

```Shell
go install golang.org/x/pkgsite/cmd/pkgsite@latest
pkgsite
```

--------------------------------

### Install OpenCensus Go Library

Source: https://github.com/googleforgames/agones/blob/main/vendor/go.opencensus.io/README.md

Instructions to install the OpenCensus Go library using the `go get` command. This command fetches and installs the latest version of the library and its dependencies. It requires Go 1.8 or later.

```Go
go get -u go.opencensus.io
```

--------------------------------

### Common Agones Development Workflows

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

Examples of combined `make` commands representing common development and testing workflows, such as building, pushing, and installing Agones, or running linting and Go unit tests.

```Bash
make build-images push install
```

```Bash
make lint test-go
```

--------------------------------

### Run Project Tests with Make

Source: https://github.com/googleforgames/agones/blob/main/vendor/go.opencensus.io/CONTRIBUTING.md

These commands are used to prepare the development environment and execute the project's test suite. `make install-tools` should be run once for initial setup to install necessary build tools, and `make` will then run the tests.

```Shell
$ make install-tools  # Only first time.
$ make
```

--------------------------------

### Example output of successful Helm test

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/helm.md

This is an example of the expected successful output after running `helm test`. It indicates that the test suite completed successfully, confirming the Agones installation.

```bash
NAME: my-release
LAST DEPLOYED: Wed Mar 29 06:13:23 2023
NAMESPACE: agones-system
STATUS: deployed
REVISION: 4
TEST SUITE:     my-release-test
Last Started:   Wed Mar 29 06:17:52 2023
Last Completed: Wed Mar 29 06:18:10 2023
Phase:          Succeeded
```

--------------------------------

### Build Node.js Example Docker Image

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Builds the Docker container image for the node.js example gameserver. This command should be run from the example's directory.

```bash
make build
```

--------------------------------

### Install Agones Go SDK

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/Client SDKs/go.md

This command facilitates the installation of the Agones Go Game Server Client SDK. It uses the `go get` tool to fetch the necessary source code directly from the Agones GitHub repository, making the SDK available for use in Go projects.

```Bash
go get agones.dev/agones/sdks/go
```

--------------------------------

### Installing and Forking fsnotify with Go and Git

Source: https://github.com/googleforgames/agones/blob/main/vendor/gopkg.in/fsnotify.v1/CONTRIBUTING.md

Instructions for installing the fsnotify project using `go get` and then setting up a local fork for development, including creating a feature branch, committing changes, and pushing to a remote fork on GitHub.

```Shell
go get -u github.com/fsnotify/fsnotify
```

```Shell
git checkout -b my-new-feature
```

```Shell
git commit -am 'Add some feature'
```

```Shell
git remote add fork git@github.com:mycompany/repo.git
```

```Shell
git push fork my-new-feature
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.20.0.md

This command installs the Agones game server management system using its official Helm chart. It specifies the chart name, repository, and the exact version to ensure a consistent deployment of Agones 1.20.0.

```Bash
helm install agones agones/agones --version 1.20.0
```

--------------------------------

### Install json-patch library

Source: https://github.com/googleforgames/agones/blob/main/vendor/gopkg.in/evanphx/json-patch.v4/README.md

Instructions for installing the `json-patch` Go library using `go get` for both the latest and stable versions.

```bash
go get -u github.com/evanphx/json-patch/v5
```

```bash
go get -u gopkg.in/evanphx/json-patch.v5
```

```bash
go get -u gopkg.in/evanphx/json-patch.v4
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.41.0.md

This command installs the Agones Helm chart from the stable repository. It specifies the release name 'agones', the chart 'agones/agones', and a specific version '1.41.0'.

```Shell
helm install agones agones/agones --version 1.41.0
```

--------------------------------

### Demonstrate Interactive Netcat Session with GameServer

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

Illustrates an example interactive session using `nc` to communicate with an Agones GameServer. It shows sending "Hello World !" and receiving an "ACK" response, followed by sending "EXIT" to trigger the GameServer's SDK shutdown command.

```shell
nc -u 35.233.183.43 7190
Hello World !
ACK: Hello World !
```

--------------------------------

### Display Help for Node.js Example Gameserver

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Shows the available command-line options and help message for the node.js example gameserver. This can be done using `make`, `docker`, or `npm`.

```bash
make args="--help" run
```

```docker
docker run --network=host us-docker.pkg.dev/agones-images/examples/nodejs-simple-server:0.10 --help
```

```npm
npm start -- --help
```

--------------------------------

### Create an Agones GameServer in Kubernetes

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

This command creates a GameServer resource in Kubernetes using a predefined YAML file from the Agones examples. It initiates the deployment of a simple UDP game server, which will also create a backing Pod.

```bash
kubectl create -f https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/examples/simple-game-server/gameserver.yaml
```

--------------------------------

### Connect and Interact with Agones GameServer

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Demonstrates how to establish a UDP connection to an Agones GameServer using 'nc' (netcat) with the retrieved IP and port. It shows an example interaction, including sending 'Hello World !' and 'EXIT' to trigger the GameServer's SDK Shutdown command.

```bash
nc -u {IP} {PORT}
Hello World !
ACK: Hello World !
EXIT
```

--------------------------------

### Example Output for GameServer Status

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/windows-gameservers.md

This snippet displays an example output from `kubectl get gameservers`, showing a GameServer in 'Ready' state with its IP, port, and assigned node.

```bash
NAME                       STATE     ADDRESS       PORT   NODE     AGE
simple-game-server-7pjrq   Ready   35.233.183.43   7190   agones   3m
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.11.0-rc.md

After adding the repository, use this command to install Agones. It deploys Agones version 1.11.0-rc from the 'agones' repository, creating the necessary Kubernetes resources for game server management.

```Shell
helm install agones agones/agones --version 1.11.0-rc
```

--------------------------------

### Install Agones with pre-generated YAML

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/yaml.md

This command sequence creates the `agones-system` namespace and applies the Agones installation manifest directly from the official GitHub repository using `kubectl`. It's the quickest way to get Agones running, but uses pre-generated TLS certificates.

```bash
kubectl create namespace agones-system
kubectl apply --server-side -f https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/install/yaml/install.yaml
```

--------------------------------

### Add Agones Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.20.0.md

Before installing the Agones Helm chart, its stable repository must be added to your local Helm configuration. This command registers the official Agones chart repository, making its charts available for installation.

```Bash
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Install json-patch Go library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/evanphx/json-patch/README.md

Instructions to install the `json-patch` Go library using `go get`. This includes commands for fetching the latest version and specific stable versions (v5 and v4).

```bash
go get -u github.com/evanphx/json-patch/v5
go get -u gopkg.in/evanphx/json-patch.v5
go get -u gopkg.in/evanphx/json-patch.v4
```

--------------------------------

### Install Google Auth Library for Go

Source: https://github.com/googleforgames/agones/blob/main/vendor/cloud.google.com/go/auth/README.md

This command installs the latest version of the Google Auth Library for Go using the `go get` tool. It fetches the module and its dependencies, making it available for use in Go projects.

```bash
go get cloud.google.com/go/auth@latest
```

--------------------------------

### Check Agones Pod Status with Kubectl

Source: https://github.com/googleforgames/agones/blob/main/install/helm/agones/templates/NOTES.txt

This command is used to list all Agones pods within the specified namespace, providing a wide output to check their current status and ensure successful installation and operation of the components.

```Shell
kubectl --namespace {{ .Release.Namespace }} get pods -o wide
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.34.0.md

This command installs the Agones game server management system using its official Helm chart. It specifies the chart name 'agones', the repository 'agones/agones', and a specific version '1.34.0' for a consistent deployment.

```Helm
helm install agones agones/agones --version 1.34.0
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.32.0.md

This command adds the official Agones stable Helm chart repository to your local Helm configuration, making it possible to fetch and install Agones charts.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Install Agones with Helm and Custom GameServer Port Range

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Creating Cluster/minikube.md

This Helm command installs Agones into the 'agones-system' namespace, setting a custom GameServer port range (7000-7100) to match the `--ports` configuration used when starting Minikube. This ensures consistency between the Minikube setup and Agones' port allocation for GameServers.

```bash
helm install my-release --namespace agones-system --create-namespace \
  --set gameservers.minPort=7000,gameservers.maxPort=7100 agones/agones
```

--------------------------------

### Run Node.js Example Gameserver via Docker

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Executes the pre-built node.js example gameserver Docker image directly, connecting to the host network.

```docker
docker run --network=host us-docker.pkg.dev/agones-images/examples/nodejs-simple-server:0.10
```

--------------------------------

### Go Get OpenCensus Repository

Source: https://github.com/googleforgames/agones/blob/main/vendor/go.opencensus.io/CONTRIBUTING.md

This command downloads the `go.opencensus.io` repository into your Go workspace (GOPATH). The `-d` flag ensures that only the source code is downloaded without installing the package, which is useful for development setup.

```Shell
$ go get -d go.opencensus.io
```

--------------------------------

### Example Output: Agones Autoscaler Webhook Pod Description

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-webhook-fleetautoscaler.md

Illustrates the expected output when describing the autoscaler webhook pod, showing key information such as name, namespace, node, and most importantly, the 'Running' status, which confirms successful deployment and operation.

```text
Name:           autoscaler-webhook-86944884c4-sdtqh
Namespace:      default
Node:           gke-test-cluster-default-1c5dec79-h0tq/10.138.0.2
...
Status:         Running
```

--------------------------------

### Run Node.js Example Gameserver Locally

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

After building the Docker image, this command runs the node.js example gameserver locally. It assumes the SDK-server is already running in a separate terminal.

```bash
make build
make run
```

--------------------------------

### fxamacker/cbor Library Quick Start and API Overview

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/fxamacker/cbor/v2/README.md

This section provides a quick start guide for installing and importing `fxamacker/cbor/v2`, along with key points about its API. It covers the library's support for CBOR data items and sequences, emphasizing configurable limits, options, and the thread-safe nature of encoding/decoding modes.

```APIDOC
Install: go get github.com/fxamacker/cbor/v2
import "github.com/fxamacker/cbor/v2"

API Overview:
- Mostly same as encoding/json, with interfaces for concurrency.
- Supports CBOR (RFC 8949) and CBOR Sequences (RFC 8742).
- CBOR data item: single piece of CBOR data, potentially nested.
- CBOR sequence: concatenation of encoded CBOR data items.
- Configurable limits and options for trade-offs.
- Encoding/decoding modes created from options, reusable, safe for concurrent use.
```

--------------------------------

### Run Go Agones SDK Conformance Test Example

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/Client SDKs/_index.md

Example command to run the conformance test specifically for the Go SDK, demonstrating how to initiate the test process for a particular SDK implementation.

```Shell
SDK_FOLDER=go make run-sdk-conformance-test
```

--------------------------------

### Retrieve Agones GameServer IP Address and Port

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

Execute `kubectl get gs` to quickly list your Agones GameServers, displaying their current state, assigned IP address, and allocated port. This command is essential for obtaining the necessary connection details for your game client.

```bash
kubectl get gs
```

--------------------------------

### Deploy Game Server to Minikube

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/edit-first-gameserver-go.md

Applies the `gameserver.yaml` configuration to a local Minikube cluster to deploy the game server.

```Bash
kubectl apply -f gameserver.yaml
```

--------------------------------

### Example GameServerAllocation Response YAML

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Shows the expected YAML output after a successful `GameServerAllocation` request. This response includes the allocated game server's details such as its address, ports, name, and crucial `status.state` indicating whether the allocation was successful (`Allocated`), failed (`UnAllocated`), or encountered contention (`Contention`).

```yaml
apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
metadata:
  creationTimestamp: 2019-02-19T02:13:12Z
  name: simple-game-server-dph9b-hfk24
  namespace: default
spec:
  metadata: {}
  required:
    matchLabels:
      agones.dev/fleet: simple-game-server
  scheduling: Packed
status:
  address: 192.168.122.152
  gameServerName: simple-game-server-dph9b-hfk24
  nodeName: minikube
  ports:
  - name: default
    port: 7714
  state: Allocated
```

--------------------------------

### Install json-iterator/go using go get

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/json-iterator/go/README.md

Provides the command to download and install the `json-iterator/go` library using the Go module system's `go get` command, making it available for use in your Go projects.

```Go
go get github.com/json-iterator/go
```

--------------------------------

### Example Agones Pods Deployment Status

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Advanced/high-availability-agones.md

This output from a `kubectl get pods` command illustrates the default deployment configuration for Agones. It shows multiple running replicas for `agones-allocator`, `agones-controller`, `agones-extensions`, and `agones-ping` pods, reflecting the high-availability setup with distributed responsibilities.

```Shell
NAME                                 READY   STATUS    RESTARTS   AGE
agones-allocator-78c6b8c79-h9nqc     1/1     Running   0          23h
agones-allocator-78c6b8c79-l2bzp     1/1     Running   0          23h
agones-allocator-78c6b8c79-rw75j     1/1     Running   0          23h
agones-controller-fbf944f4-vs9xx     1/1     Running   0          23h
agones-controller-fbf944f4-sjk3t     1/1     Running   0          23h
agones-extensions-5648fc7dcf-hm6lk   1/1     Running   0          23h
agones-extensions-5648fc7dcf-qbc6h   1/1     Running   0          23h
agones-ping-5b9647874-2rrl6          1/1     Running   0          27h
agones-ping-5b9647874-rksgg          1/1     Running   0          27h
```

--------------------------------

### Install Afero Go Library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/spf13/afero/README.md

Instructions to install the Afero library using the Go package manager.

```Shell
go get github.com/spf13/afero
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.39.0.md

Installs the Agones Helm chart from the stable repository with a specific version. This command deploys Agones to your Kubernetes cluster.

```Shell
helm install agones agones/agones --version 1.39.0
```

--------------------------------

### Agones Helm Repository and Installation

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.16.0-rc.md

These commands add the Agones stable Helm repository and then install Agones using Helm, specifying a particular release candidate version. The repository addition is a prerequisite for the installation.

```shell
helm repo add agones https://agones.dev/chart/stable
```

```shell
helm install agones agones/agones --version 1.16.0-rc
```

--------------------------------

### Build Docker Image for Node.js Agones Gameserver

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Tutorials/simple-gameserver-nodejs.md

Navigate to the `examples/nodejs-simple` directory and use `make build` to create a new Docker image for the gameserver. Replace `<your-repository>` with your desired Docker registry path.

```bash
cd examples/nodejs-simple
REPOSITORY=<your-repository> # e.g. gcr.io/agones-images
make build REPOSITORY=${REPOSITORY}
```

--------------------------------

### Install Agones with Helm using --set parameters

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/helm.md

This command installs Agones into the `agones-system` namespace using Helm. It demonstrates how to set specific configuration parameters, such as the GameServers' port allocation range, directly via the `--set` argument during installation.

```bash
helm install my-release --namespace agones-system \
  --set gameservers.minPort=1000,gameservers.maxPort=5000 agones
```

--------------------------------

### Building and Deploying Agones Game Server Docker Image

Source: https://github.com/googleforgames/agones/blob/main/examples/unity-simple/README.md

Provides shell commands to build a Docker image for the Unity game server and subsequently deploy it to a Kubernetes cluster using kubectl.

```Shell
$ make build-image
$ kubectl create -f gameserver.yaml
```

--------------------------------

### Install Agones using Helm

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.42.0.md

This command installs the Agones game server management system using Helm. It specifies the chart name 'agones/agones' and installs version '1.42.0' from the configured repository.

```Shell
helm install agones agones/agones --version 1.42.0
```

--------------------------------

### Verify Agones GameServer Instances After Scaling

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-webhook-fleetautoscaler.md

Execute this command to get an updated list of all GameServers in the default namespace and their current states. This verifies the actual number of running game server instances and their status after the autoscaler has adjusted the fleet size.

```bash
kubectl get gs -n default
```

--------------------------------

### Interact with Game Server using Netcat

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/edit-first-gameserver-go.md

Initiates a UDP connection to the game server using `netcat`, sends 'Hello World!' and 'EXIT' messages, and shows the expected server response.

```Bash
nc -u {IP} {PORT}
Hello World!
EXIT
```

--------------------------------

### Install Agones with Helm

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.29.0.md

Installs a specific version of Agones using the Helm package manager. This command deploys the Agones chart from the previously added 'agones' repository.

```Shell
helm install agones agones/agones --version 1.29.0
```

--------------------------------

### Deploy Agones Simple Game Server Fleet

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-webhook-fleetautoscaler.md

This command deploys a simple game server fleet to the Kubernetes cluster using the provided YAML configuration from the Agones examples repository. This fleet will be managed by the autoscaler webhook.

```bash
kubectl apply -f https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/examples/simple-game-server/fleet.yaml
```

--------------------------------

### Get Agones Fleet Overview

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Retrieves a high-level summary of all Agones Fleets deployed in the current Kubernetes namespace. The output displays key metrics such as desired, current, allocated, and ready replica counts, providing an immediate status of the fleet's health and capacity.

```bash
kubectl get fleet
```

--------------------------------

### Deploy and Verify Agones GameServer Creation Job with Kubectl

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/access-api.md

These `kubectl` commands illustrate how to deploy the Go GameServer creation example as a Kubernetes Job, monitor its execution, and inspect the logs to confirm the successful creation of the GameServer resource.

```bash
kubectl create -f https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/examples/crd-client/create-gs.yaml --namespace agones-system
```

```bash
kubectl get pods --namespace agones-system
```

```bash
kubectl logs create-gs-6wz86-7qsm5 --namespace agones-system
```

--------------------------------

### Install Agones with Custom Game Server Namespaces

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/helm.md

This command demonstrates how to install Agones while configuring it to manage game servers in multiple specified namespaces (e.g., `default` and `xbox`). It first creates the `xbox` namespace and then installs Agones, setting the `gameservers.namespaces` parameter.

```bash
kubectl create namespace xbox
helm install my-release agones/agones --set "gameservers.namespaces={default,xbox}" --namespace agones-system
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.41.0.md

This command adds the official Agones stable Helm repository to your local Helm configuration. This is a prerequisite for installing Agones charts using 'helm install'.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Check GameServer States with kubectl get gs

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Provides the `kubectl` command to list all current Agones GameServers and their respective `Status.State`. This allows users to monitor the number of `Allocated` versus `Ready` game servers within their cluster, providing an overview of fleet health.

```bash
kubectl get gs
```

--------------------------------

### Install Blackfriday Command-Line Tool

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/russross/blackfriday/v2/README.md

Command to download and install `blackfriday-tool`, a simple command-line utility that allows processing markdown files using a standalone program. Installing this tool will also be sufficient to download and install the Blackfriday library itself.

```Go
go get github.com/russross/blackfriday-tool
```

--------------------------------

### Install Agones with Helm

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.29.0-rc.md

This command installs the Agones game server management system using Helm. It specifies the chart name 'agones/agones' and targets a specific release candidate version '1.29.0-rc' from the configured repository.

```shell
helm install agones agones/agones --version 1.29.0-rc
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.29.0-rc.md

Before installing Agones charts, you must add the official stable Agones Helm repository to your Helm configuration. This command registers the repository, making its charts available for installation.

```shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### List all Agones GameServers

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

This command retrieves a list of all GameServer resources currently managed by Agones in the Kubernetes cluster, showing their state, address, port, node, and age.

```bash
kubectl get gameservers
```

--------------------------------

### Go: Install and Import healthcheck Library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/heptiolabs/healthcheck/README.md

Instructions for installing the `healthcheck` Go library using `go get` and importing it into a Go project to begin using its functionalities.

```Go
go get -u github.com/heptiolabs/healthcheck
import "github.com/heptiolabs/healthcheck"
```

--------------------------------

### Verify Agones GameServer States

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-fleet.md

Use this command to quickly check the current states (e.g., Ready, Allocated) of all GameServers within your Agones Fleet. It provides an overview of the fleet's operational status.

```bash
kubectl get gs
```

--------------------------------

### Install Go mapstructure Library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/mitchellh/mapstructure/README.md

Installs the mapstructure Go library using the standard `go get` command, making it available for use in Go projects.

```Shell
go get github.com/mitchellh/mapstructure
```

--------------------------------

### Configure Agones Local SDK Server with Custom GameServer YAML

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/Client SDKs/local.md

This snippet demonstrates how to start the Agones local SDK server (`sdk-server.linux.amd64`) and provide a custom GameServer configuration file (e.g., `gameserver.yaml`) using the `--file` or `-f` flag. It also includes the typical console output from the server during startup, showing the configuration being loaded and services starting.

```bash
wget https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/examples/simple-game-server/gameserver.yaml
./sdk-server.linux.amd64 --local -f ./gameserver.yaml
```

```json
{"ctlConf":{"Address":"localhost","IsLocal":true,"LocalFile":"./gameserver.yaml","Delay":0,"Timeout":0,"Test":"","GRPCPort":9357,"HTTPPort":9358},"message":"Starting sdk sidecar","severity":"info","source":"main","time":"2019-10-30T21:47:45.742776+03:00","version":"1.1.0"}
{"filePath":"/Users/alexander.apalikov/Downloads/agonessdk-server-1.1.0/gameserver.yaml","message":"Reading GameServer configuration","severity":"info","time":"2019-10-30T21:47:45.743369+03:00"}
{"grpcEndpoint":"localhost:9357","message":"Starting SDKServer grpc service...","severity":"info","source":"main","time":"2019-10-30T21:47:45.759692+03:00"}
{"httpEndpoint":"localhost:9358","message":"Starting SDKServer grpc-gateway...","severity":"info","source":"main","time":"2019-10-30T21:47:45.760312+03:00"}
```

--------------------------------

### Install Agones Helm Chart Version 1.32.0

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.32.0.md

Use this command to install the Agones game server management system into your Kubernetes cluster via its Helm chart, specifically targeting version 1.32.0.

```Shell
helm install agones agones/agones --version 1.32.0
```

--------------------------------

### Deploy Pre-built Agones Rust Gameserver

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Tutorials/simple-gameserver-rust.md

This command deploys a pre-built Agones Rust gameserver using a provided YAML configuration and captures its dynamically generated name for subsequent operations. It's the initial step to get a simple gameserver running.

```bash
kubectl create -f https://raw.githubusercontent.com/googleforgames/agones/{{< release-branch >}}/examples/rust-simple/gameserver.yaml
GAMESERVER_NAME=$(kubectl get gs -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}')
```

--------------------------------

### Install Go longrunning library

Source: https://github.com/googleforgames/agones/blob/main/vendor/cloud.google.com/go/longrunning/README.md

This command installs the `cloud.google.com/go/longrunning` Go module using the `go get` tool. It fetches the latest version of the library and adds it to your Go module dependencies.

```Bash
go get cloud.google.com/go/longrunning
```

--------------------------------

### Install Blackfriday Go Module

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/russross/blackfriday/v2/README.md

Instructions for installing the Blackfriday v2 Go module. This can be done using `go get` to resolve and add the package to the current development module, or by simply importing it in a Go package and running `go get` without parameters. This method is compatible with modern Go releases in module mode.

```Go
go get github.com/russross/blackfriday/v2
```

```Go
import "github.com/russross/blackfriday/v2"
```

--------------------------------

### Unity Editor and OS Prerequisites

Source: https://github.com/googleforgames/agones/blob/main/examples/unity-simple/README.md

Specifies the minimum Unity Editor version and supported operating systems required for this example to function correctly.

```Text
Unity Editor: Unity 2018.4.2f1 or later
OS: Windows 10 Pro or MacOS
```

--------------------------------

### Install hashstructure Go library

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/mitchellh/hashstructure/v2/README.md

Standard Go get command to install the hashstructure/v2 library. It is highly recommended to use the 'v2' release as it fixes significant hash collision issues from v1.

```Go
$ go get github.com/mitchellh/hashstructure/v2
```

--------------------------------

### Execute Pre-Release Build and Deployment

Source: https://github.com/googleforgames/agones/blob/main/docs/governance/templates/release_issue.md

Runs essential pre-release build tasks, including verifying the existence of all example images in the `agones-images/examples` repository and deploying a versioned service to GCP App Engine.

```Shell
make pre-build-release
```

--------------------------------

### Add Agones Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.39.0.md

Adds the official Agones stable Helm repository to your local Helm configuration. This is a prerequisite step before installing Agones charts from the repository.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Build Custom Docker Image for Agones Rust Gameserver

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Tutorials/simple-gameserver-rust.md

These commands navigate to the Rust gameserver example directory and then execute a `make` command to build a new Docker image. The `REPOSITORY` variable specifies the target Docker registry for the image, allowing for customization and local development.

```bash
cd examples/rust-simple
REPOSITORY=<your-repository> # e.g. gcr.io/agones-images
make build-image REPOSITORY=${REPOSITORY}
```

--------------------------------

### Agones Controller Configuration Reference

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/helm.md

Detailed reference for all configurable parameters of the Agones controller, including their purpose, default values, and any deprecation notices with recommended alternatives.

```APIDOC
agones.controller.affinity: {}
  Description: Controller affinity settings for pod assignment
```

```APIDOC
agones.controller.labels: {}
  Description: Labels added to the Agones controller pods
```

```APIDOC
agones.controller.annotations: {}
  Description: Annotations added to the Agones controller pods
```

```APIDOC
agones.controller.numWorkers: 100
  Description: Number of workers to spin per resource type
```

```APIDOC
agones.controller.apiServerQPS: 400
  Description: Maximum sustained queries per second that controller should be making against API Server
```

```APIDOC
agones.controller.apiServerQPSBurst: 500
  Description: Maximum burst queries per second that controller should be making against API Server
```

```APIDOC
agones.controller.logLevel: info
  Description: Agones Controller Log level. Log only entries with that severity and above
```

```APIDOC
agones.controller.persistentLogs: true
  Description: Store Agones controller logs in a temporary volume attached to a container for debugging
```

```APIDOC
agones.controller.persistentLogsSizeLimitMB: 10000
  Description: Maximum total size of all Agones container logs in MB
```

```APIDOC
agones.controller.disableSecret: false
  Description: DEPRECATED. Use agones.extensions.disableSecret instead. Disables the creation of any allocator secrets. If true, you MUST provide the {agones.releaseName}-cert secrets before installation.
```

```APIDOC
agones.controller.customCertSecretPath: {}
  Description: Remap cert-manager path to server.crt and server.key
```

```APIDOC
agones.controller.allocationApiService.annotations: {}
  Description: DEPRECATED. Use agones.extensions.allocationApiService.annotations instead. Annotations added to the Agones apiregistration
```

```APIDOC
agones.controller.allocationApiService.disableCaBundle: false
  Description: DEPRECATED. Use agones.extensions.allocationApiService.disableCaBundle instead. Disable ca-bundle so it can be injected by cert-manager.
```

```APIDOC
agones.controller.validatingWebhook.annotations: {}
  Description: DEPRECATED. Use agones.extensions.validatingWebhook.annotations instead. Annotations added to the Agones validating webhook
```

```APIDOC
agones.controller.validatingWebhook.disableCaBundle: false
  Description: DEPRECATED. Use agones.extensions.validatingWebhook.disableCaBundle instead. Disable ca-bundle so it can be injected by cert-manager
```

```APIDOC
agones.controller.mutatingWebhook.annotations: {}
  Description: DEPRECATED. Use agones.extensions.mutatingWebhook.annotations instead. Annotations added to the Agones mutating webhook
```

--------------------------------

### Install Prometheus Stack for Agones Metrics

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

This command installs the Prometheus-stack into the current cluster using the Prometheus Community Helm chart. By default, only Prometheus and Grafana are installed, with all exporters and Alertmanager disabled. This setup uses ServiceMonitor to collect Agones metrics. See `make minikube-setup-prometheus-stack` and `make kind-setup-prometheus-stack` for Minikube or Kind installations.

```bash
make setup-prometheus-stack
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.29.0.md

Adds the official Agones stable Helm chart repository to your Helm configuration. This step is necessary before you can install Agones charts from their repository.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Start pprof Web Interface for CPU Profiling

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

This command starts the web interface for `pprof` to analyze CPU profiling data.

```bash
make pprof-cpu-web
```

--------------------------------

### Run Agones SDK Conformance Server Locally

Source: https://github.com/googleforgames/agones/blob/main/examples/rust-simple/README.md

Initiates a local Agones SDK conformance server, essential for testing the Rust gameserver example. It runs for a specified timeout and enables specific tests like ready, watch, health, and gameserver updates.

```bash
$ cd ../../build; make run-sdk-conformance-local TIMEOUT=120 TESTS=ready,watch,health,gameserver
```

--------------------------------

### Run Local Site Server for Release Review

Source: https://github.com/googleforgames/agones/blob/main/docs/governance/templates/release_issue.md

Starts a local server to preview the Agones website, allowing frequent checks to ensure all release-related content and updates appear correctly before publishing.

```Shell
make site-server
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.22.0.md

Installs the Agones Helm chart version 1.22.0 into your Kubernetes cluster. This command deploys the Agones game server management system.

```Shell
helm install agones agones/agones --version 1.22.0
```

--------------------------------

### Install and Import `kubernetes-sigs/yaml` Go Package

Source: https://github.com/googleforgames/agones/blob/main/vendor/sigs.k8s.io/yaml/README.md

Instructions for installing the `kubernetes-sigs/yaml` Go module using `go get` and importing it into a Go source file to begin using its functionalities.

```Shell
$ go get sigs.k8s.io/yaml
```

```Go
import "sigs.k8s.io/yaml"
```

--------------------------------

### Start pprof Web Interface for Heap Profiling

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

This command starts the web interface for `pprof` to analyze heap profiling data.

```bash
make pprof-heap-web
```

--------------------------------

### Build Docker Image for Agones C++ Game Server

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Tutorials/simple-gameserver-cpp.md

This command sequence navigates to the C++ simple example directory and builds a Docker image for the game server. It uses `make build` with a specified `REPOSITORY` variable, which should be set to your Docker image repository (e.g., `gcr.io/agones-images`). This process compiles the C++ code and packages it into a container image.

```bash
cd examples/cpp-simple
REPOSITORY=<your-repository> # e.g. gcr.io/agones-images
make build REPOSITORY=${REPOSITORY}
```

--------------------------------

### Build and Run Rust Gameserver Docker Image

Source: https://github.com/googleforgames/agones/blob/main/examples/rust-simple/README.md

Commands to build the Docker image for the Rust example gameserver and then execute it. This allows testing the gameserver within a containerized environment against a locally running SDK server.

```bash
$ make build-image
$ make run-image
```

--------------------------------

### List Kubernetes Pods related to GameServers

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

This command lists all Kubernetes Pods, allowing identification of the backing Pods created for Agones GameServers. These Pods are typically prefixed by the GameServer name and include an SDK sidecar for readiness and health checking.

```bash
kubectl get pods
```

--------------------------------

### Install Prometheus Server for Agones Metrics

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

This command installs the Prometheus server into the current cluster using the Prometheus Community Helm chart. By default, all exporters and Alertmanager are disabled. This setup can be used to collect Agones metrics. See `make minikube-setup-prometheus` and `make kind-setup-prometheus` for Minikube or Kind installations.

```bash
make setup-prometheus
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.42.0.md

This command adds the official stable Agones Helm chart repository to your local Helm configuration. This step is necessary before you can install Agones charts from their repository.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Run fsnotify Examples from Command Line

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/fsnotify/fsnotify/README.md

This command shows how to execute the example programs provided within the fsnotify repository's 'cmd/fsnotify' directory using the Go runtime.

```Shell
go run ./cmd/fsnotify
```

--------------------------------

### Initializing Afero OsFs for Native OS File Operations

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/spf13/afero/README.md

Demonstrates how to initialize `OsFs`, Afero's wrapper around native operating system file calls. This backend allows code to interact with the actual file system, making it easy to switch between OS operations and mock file systems for testing.

```go
appfs := afero.NewOsFs()
appfs.MkdirAll("src/a", 0755)
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Install Agones/helm.md

This command sequence adds the Agones stable Helm repository, updates the local Helm repositories, and then installs the Agones chart into the `agones-system` namespace. It also creates the namespace if it doesn't exist. This is the recommended way to deploy Agones.

```bash
helm repo add agones https://agones.dev/chart/stable
helm repo update
helm install my-release --namespace agones-system --create-namespace agones/agones
```

--------------------------------

### Add Agones Stable Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.11.0-rc.md

Before installing Agones, you must add its stable Helm chart repository to your Helm configuration. This command registers the Agones repository, allowing Helm to locate and download the Agones charts.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Example JSON Configuration for Consul K/V Store

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/spf13/viper/README.md

A sample JSON structure to be stored in a Consul Key/Value store, demonstrating a simple configuration with port and hostname.

```json
{
    "port": 8080,
    "hostname": "myhostname.com"
}
```

--------------------------------

### Install Agones Helm Chart

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.45.0.md

Command to install the Agones Helm chart for version 1.45.0 into your Kubernetes cluster. This command deploys the Agones game server management system.

```Helm
helm install agones agones/agones --version 1.45.0
```

--------------------------------

### Install OpenCensus Go Prometheus Exporter

Source: https://github.com/googleforgames/agones/blob/main/vendor/contrib.go.opencensus.io/exporter/prometheus/README.md

Installs the OpenCensus Go Prometheus Exporter library using the `go get` command. This command fetches the latest version of the library and its dependencies, making it available for use in Go projects.

```Shell
$ go get -u contrib.go.opencensus.io/exporter/prometheus
```

--------------------------------

### Install and Test pflag Go Package

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/spf13/pflag/README.md

Instructions to install the pflag library using the standard Go package manager and how to run its tests.

```Go
go get github.com/spf13/pflag
```

```Go
go test github.com/spf13/pflag
```

--------------------------------

### Build and Push Docker Image to GCP Registry

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/edit-first-gameserver-go.md

Uses the Makefile to build a new Docker image for the game server and push it to the specified Google Container Registry, excluding Windows and ARM64 builds.

```Bash
make WITH_WINDOWS=0 WITH_ARM64=0 REPOSITORY={$REGISTRY} push
```

--------------------------------

### Load Docker Image into Minikube Cache

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/edit-first-gameserver-go.md

Adds the newly built Docker image to the Minikube cache, making it available for local deployments without pulling from a remote registry.

```Bash
minikube cache add gcr.io/[PROJECT_ID]/agones-agones-simple-game-server:modified
```

--------------------------------

### Create ClusterRoleBinding for Agones Installation on Older Kubernetes

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/troubleshooting.md

If you encounter 'Forbidden' errors when installing Agones on Kubernetes versions older than 1.12, you need to manually create a clusterrolebinding to grant your identity cluster-admin permissions. Examples are provided for Kubernetes Engine (GKE) and Minikube.

```bash
# Kubernetes Engine
kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole cluster-admin --user `gcloud config get-value account`
# Minikube
kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin --serviceaccount=kube-system:default
```

--------------------------------

### Run Pkgsite Container with Make

Source: https://github.com/googleforgames/agones/blob/main/build/README.md

Starts a container running pkgsite, accessible on port 8888, for browsing Go package documentation.

```Shell
make pkgsite
```

--------------------------------

### Example Output: Kubeconfig Update Confirmation

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Terraform/eks.md

An example of the output displayed after successfully updating the kubeconfig file. This confirms that a new context for the Agones EKS cluster has been added to the user's kubeconfig, making it available for use with 'kubectl'.

```bash
Added new context arn:aws:eks:us-west-2:601646756426:cluster/agones-cluster to /Users/user/.kube/config
```

--------------------------------

### Initialize Google Cloud SDK Configuration

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Terraform/gke.md

This command initializes the Google Cloud SDK, guiding you through the process of setting up default configurations, including your project, compute region, and zone. It's a crucial step after installing the SDK on a local machine.

```bash
gcloud init
```

--------------------------------

### Monitor Agones GameServer State with kubectl describe

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-gameserver.md

Use the `watch` command to continuously observe the detailed status of an Agones GameServer, specifically waiting for its `State` to become `Ready`. This command provides real-time updates on the GameServer's lifecycle, including address, port, and events.

```bash
watch kubectl describe gameserver
```

--------------------------------

### Get Agones GameServer Instances Status

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Getting Started/create-webhook-fleetautoscaler.md

Lists all current `GameServers` in the `default` namespace, showing their `STATE`, `ADDRESS`, `PORT`, `NODE`, and `AGE`. This command is used to verify the actual number and status of game server instances after autoscaling events.

Example Output:
```
NAME                     STATE       ADDRESS         PORT      NODE      AGE
simple-game-server-njmr7-2t4nx   Ready       35.203.159.68   7330      minikube   1m
simple-game-server-njmr7-65rp6   Allocated   35.203.159.68   7294      minikube   4m
```

```bash
kubectl get gs -n default
```

--------------------------------

### Retrieving Agones GameServer Address and Port

Source: https://github.com/googleforgames/agones/blob/main/examples/unity-simple/README.md

Illustrates the kubectl command used to list running Agones GameServers, displaying their state, IP address, port, and node information for client connection.

```Shell
$ kubectl get gs 
NAME                        STATE   ADDRESS         PORT   NODE       AGE
unity-simple-server-z7nln   Ready   192.168.*.*     7854   node-name  1m
```

--------------------------------

### Get AKS Cluster Credentials for Kubectl

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Installation/Terraform/aks.md

Retrieve the Kubernetes cluster credentials to configure `kubectl` for interacting with your AKS cluster.

```bash
az aks get-credentials --resource-group agonesRG --name test-cluster
```

--------------------------------

### Enable Player Tracking Alpha Feature in SDK-Server

Source: https://github.com/googleforgames/agones/blob/main/examples/nodejs-simple/README.md

Starts the local Agones SDK-server with the 'PlayerTracking' alpha feature gate enabled. This is required for testing player-related alpha functionalities.

```bash
cd ../../build; make run-sdk-conformance-local TIMEOUT=120 FEATURE_GATES="PlayerTracking=true" TESTS=ready,watch,health,gameserver
```

--------------------------------

### Start Docker Compose Services

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/docs/Guides/Client SDKs/local.md

This command initiates the services defined in the `docker-compose.yaml` file, building images if necessary, to bring up the game server and Agones SDK server.

```shell
docker-compose up --build
```

--------------------------------

### Install and use tomll TOML linter tool

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/pelletier/go-toml/README.md

Instructions to install the `tomll` command-line tool, which reads and lints TOML files, and how to view its help documentation.

```Go
go install github.com/pelletier/go-toml/cmd/tomll
tomll --help
```

--------------------------------

### Add Agones Helm Repository

Source: https://github.com/googleforgames/agones/blob/main/site/content/en/blog/releases/1.22.0.md

Adds the official stable Agones Helm chart repository to your local Helm configuration. This is a prerequisite for installing Agones charts.

```Shell
helm repo add agones https://agones.dev/chart/stable
```

--------------------------------

### Generate Example Image Markdown for Release Notes

Source: https://github.com/googleforgames/agones/blob/main/docs/governance/templates/release_issue.md

Generates markdown content that lists all example images available with the current release, intended to be appended to the 'Images available with this release' section of the draft release notes.

```Shell
make release-example-image-markdown
```

--------------------------------

### HCL Multi-line String (Here Document) Example

Source: https://github.com/googleforgames/agones/blob/main/vendor/github.com/hashicorp/hcl/README.md

Demonstrates the 'here document' syntax in HCL for defining multi-line strings. This syntax starts with '<<TAG' and ends with 'TAG' on its own line, where 'TAG' can be any identifier.

```HCL
<<FOO
hello
world
FOO
```