Update ports

docs/quickstart.mdx

@@ -38,7 +38,7 @@ npm run build
 npm run app
 ```
 
-This starts the greeter service on port 8080.
+This starts the greeter service on port 9080.
 
 ## Step 4: Launch the Restate runtime
 
@@ -53,7 +53,7 @@ docker run --name restate_dev --rm -d --network=host ghcr.io/restatedev/restate-
 
 Discover the services:
 ```shell
-curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json' -d '{"uri": "http://localhost:8080"}'
+curl -X POST http://localhost:9070/endpoints -H 'content-type: application/json' -d '{"uri": "http://localhost:9080"}'
 ```
 
 
@@ -63,13 +63,13 @@ curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json'
 Run the Restate Docker container:
 
 ```shell
-docker run --name restate_dev --rm -d -p 8081:8081 -p 9091:9091 -p 9090:9090 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
+docker run --name restate_dev --rm -d -p 8080:8080 -p 9070:9070 -p 9071:9071 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
 ```
 
 Discover the services:
 
 ```shell
-curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:8080"}'
+curl -X POST http://localhost:9070/endpoints -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:9080"}'
 ```
 
 </TabItem>
@@ -81,7 +81,7 @@ curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json'
 Invoke the function via:
 
 ```shell
-curl -X POST http://localhost:9090/myservice/hello -H 'content-type: application/json' -d '{"request": "Pete"}'
+curl -X POST http://localhost:8080/myservice/hello -H 'content-type: application/json' -d '{"request": "Pete"}'
 ```
 
 Congratulations, you managed to run your first Restate service.

docs/restate/deployment.md

@@ -10,9 +10,9 @@
 
 | Name    | Port | Description                                                                 | Protocol                                          |
 |---------|------|-----------------------------------------------------------------------------|---------------------------------------------------|
-| Ingress | 9090 | Acts as an API gateway for all services registered with Restate             | gRPC + [Connect Protocol](https://connect.build/) |
-| Storage | 9091 | Exposes raw RocksDB read-only storage operations, used by the CLI           | gRPC                                              |
-| Meta    | 8081 | Allows for CRUD operations on service metadata, eg for service registration | REST                                              |
+| Ingress | 8080 | Acts as an API gateway for all services registered with Restate             | gRPC + [Connect Protocol](https://connect.build/) |
+| Storage | 9071 | Exposes raw RocksDB read-only storage operations, used by the CLI           | gRPC                                              |
+| Meta    | 9070 | Allows for CRUD operations on service metadata, eg for service registration | REST                                              |
 
 It will store metadata and RocksDB data in the relative directory of /target under the current working directory of the process.
 
@@ -55,11 +55,11 @@
             - name: RESTATE_TRACING__LOG_FORMAT
               value: Json
           ports:
-            - containerPort: 8081
+            - containerPort: 9070
               name: meta
-            - containerPort: 9090
+            - containerPort: 8080
               name: ingress
-            - containerPort: 9091
+            - containerPort: 9071
               name: storage
           imagePullPolicy: IfNotPresent
           resources:
@@ -90,11 +90,11 @@
   selector:
     app: restate
   ports:
-    - port: 8081
+    - port: 9070
       name: meta
-    - port: 9090
+    - port: 8080
       name: ingress
-    - port: 9091
+    - port: 9071
       name: storage
   type: ClusterIP
 ```

docs/restate/tracing.md

@@ -55,7 +55,7 @@ docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOIN
 <TabItem value="mac" label="macOS">
 
 ```shell
-docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOINT=http://host.docker.internal:4317 -p 8081:8081 -p 9091:9091 -p 9090:9090 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
+docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOINT=http://host.docker.internal:4317 -p 8080:8080 -p 9070:9070 -p 9071:9071 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
 ```
 
 </TabItem>

docs/services/deployment/kubernetes.md

@@ -42,6 +42,9 @@ spec:
       containers:
         - name: service
           image: path.to/yourrepo:yourtag
+          env:
+            - name: PORT
+              value: 8080
           ports:
             - containerPort: 8080
               name: http2
@@ -81,6 +84,9 @@ spec:
     spec:
       containers:
         - image: path.to/yourrepo:yourtag
+          env:
+            - name: PORT
+              value: 8080
           ports:
             - name: h2c
               containerPort: 8080

docs/services/deployment/lambda.md

@@ -40,14 +40,14 @@ pointed at the Restate runtime and with the Lambda function endpoint as the URI
 
 
 ```shell
-curl -X POST http://<your-restate-runtime-endpoint>:8081/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/<my-service>"}'
+curl -X POST http://<your-restate-runtime-endpoint>:9070/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/<my-service>"}'
 ```
 
 If your Lambda function requires authentication via an API key,
 then you can add this API key to the discovery request to the Restate runtime, as follows:
 
 ```shell
-curl -X POST http://<your-restate-runtime-endpoint>:8081/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/<my-service>","additional_headers": {"x-api-key": "someapikey"} }'
+curl -X POST http://<your-restate-runtime-endpoint>:9070/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/<my-service>","additional_headers": {"x-api-key": "someapikey"} }'
 ```
 
 Here, we added the API key as an additional header to the JSON data of the request.
@@ -258,7 +258,7 @@ docker run --name restate_dev --rm -d --network=host ghcr.io/restatedev/restate-
 ```
 - On macOS:
 ```shell
-docker run --name restate_dev --rm -d -p 8081:8081 -p 9091:9091 -p 9090:9090 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
+docker run --name restate_dev --rm -d -p 8080:8080 -p 9070:9070 -p 9071:9071 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
 ```
 
 Consult the runtime logs via `docker logs restate_dev`.
@@ -270,7 +270,7 @@ Stop the runtime (and remove any intermediate state) with `docker stop restate_d
 Connect to the Restate (e.g. via an SSH session if it is running on EC2) runtime and execute the discovery curl command:
 
 ```shell
-curl -X POST http://<your-restate-runtime-endpoint>:8081/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/my-greeter", "additional_headers": {"x-api-key": "your-api-key"} }'
+curl -X POST http://<your-restate-runtime-endpoint>:9070/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/my-greeter", "additional_headers": {"x-api-key": "your-api-key"} }'
 ```
 
 If you are running the runtime locally, replace `<your-restate-runtime-endpoint>` by `localhost`.
@@ -283,7 +283,7 @@ After the discovery, the runtime uses this API key for all subsequent requests t
 
 If your Lambda function does not require an API key then you can do the discovery without the additional headers:
 ```shell
-curl -X POST http://<your-restate-runtime-endpoint>:8081/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/my-greeter"}'
+curl -X POST http://<your-restate-runtime-endpoint>:9070/endpoints -H 'content-type: application/json' -d '{"uri": "https://<lambda-function-endpoint>/default/my-greeter"}'
 ```
 
 When executing this command, you should see the discovered services printed out!
@@ -297,7 +297,7 @@ When executing this command, you should see the discovered services printed out!
 Now let's invoke the `MultiWord` method of our service! Don't forget to replace `<your-restate-runtime-endpoint>` accordingly.
 
 ```shell
-curl -X POST http://<your-restate-runtime-endpoint>:9090/org.example.Greeter/MultiWord -H 'content-type: application/json' -d '{"name": "Pete"}'
+curl -X POST http://<your-restate-runtime-endpoint>:8080/org.example.Greeter/MultiWord -H 'content-type: application/json' -d '{"name": "Pete"}'
 ```
 
 You should see the response:

docs/services/introspection.md

@@ -22,10 +22,10 @@ To let you do this, Restate exposes two SQL tables that you can query via the [*
 Connect with *psql* to Restate:
 
 ```shell
-psql -h localhost
+psql -h localhost -p 9071
 ```
 
-You can change the default postgres port `5432` by supplying the `-p` argument.
+You can change the default port `9071` by supplying the `-p` argument.
 
 The Restate Introspection SQL API has been implemented based on [DataFusion](https://arrow.apache.org/datafusion/) and supports standard SQL syntax.
 

docs/services/invocation.md

@@ -111,7 +111,7 @@ $ curl -X PATCH <RESTATE_META_ENDPOINT>/services/<SERVICE_NAME> -H 'content-type
 For example:
 
 ```shell
-$ curl -X PATCH localhost:8081/services/org.example.ExampleService -H 'content-type: application/json' -d '{"public": false}'
+$ curl -X PATCH localhost:9070/services/org.example.ExampleService -H 'content-type: application/json' -d '{"public": false}'
 ```
 
 You can revert it back to public with `{"public": true}`. Private services can still be reached by other Restate services.
@@ -126,7 +126,7 @@ You can find this identifier in the runtime logs and OpenTelemetry traces by loo
 ```log {7}
 2023-05-19T15:02:28.656467Z INFO restate_invoker::invocation_task
   Executing invocation at service endpoint
-    http.url: http://localhost:8080/invoke/coordinator.Coordinator/Sleep
+    http.url: http://localhost:9080/invoke/coordinator.Coordinator/Sleep
   in restate_invoker::invocation_task::invoker_invocation_task
     rpc.system: "restate"
     rpc.service: coordinator.Coordinator
@@ -172,7 +172,7 @@ $ curl -X DELETE <RESTATE_META_ENDPOINT>/invocations/<INVOCATION_IDENTIFIER>
 For example:
 
 ```shell
-$ curl -X DELETE http://localhost:8081/invocations/T4pIkIJIGAsBiiGDV2dxK7PkkKnWyWHE
+$ curl -X DELETE http://localhost:9070/invocations/T4pIkIJIGAsBiiGDV2dxK7PkkKnWyWHE
 ```
 
 For more details on the API, refer to the [admin API docs](/references/admin-api).

docs/services/sdk/awakeables.md

@@ -73,7 +73,7 @@ curl -X POST http://<restate-runtime-host-port>/dev.restate.Awakeables/Resolve -
 For example:
 
 ```shell
-curl -X POST http://localhost:9090/dev.restate.Awakeables/Resolve -H 'content-type: application/json' -d '{"id": "T4pIkIJIGAsBiiGDV2dxK7PkkKnWyWHE", "json_result": {"hello": "world"}}'
+curl -X POST http://localhost:8080/dev.restate.Awakeables/Resolve -H 'content-type: application/json' -d '{"id": "T4pIkIJIGAsBiiGDV2dxK7PkkKnWyWHE", "json_result": {"hello": "world"}}'
 ```
 
 To reject an awakeable:

docs/services/sdk/kafka.mdx

@@ -52,7 +52,7 @@ const router = restate.keyedRouter({
     // Other rpc or event handlers
 });
 
-restate.createServer().bindKeyedRouter("myRouter", router).listen(8080);
+restate.createServer().bindKeyedRouter("myRouter", router).listen();
 ```
 
 The Kafka record key must be a valid UTF-8 string, otherwise Restate won't be able to deliver the event to the service.

docs/services/sdk/overview.mdx

@@ -53,13 +53,13 @@
     .bindKeyedRouter("greeter", restate.keyedRouter({
         greet: sayHello, countGreetings: doCountGreetings
     }))
-    .listen(8080);
+    .listen();
 ```
 
 The app logic is implemented inside `doGreet` and `doCountGreetings`.
 These functions have the `restate.RpcContext` as their first parameter. This context is used to interact with Restate (call other methods, retrieve state, etc.).
 Then, the service is registered as a keyed service under the path `greeter`, and the `greet` and `countGreetings` routes are added.
-The `greet` function can now be called by sending a request to `<restate-host>:9090/greeter/greet` or `<restate-host>:9090/greeter/countGreetings`.
+The `greet` function can now be called by sending a request to `<restate-host>:8080/greeter/greet` or `<restate-host>:8080/greeter/countGreetings`.
 For more information on how to set up the routers and the Restate server, have a look at the [serving docs](/services/sdk/serving).
 
 </TabItem>
@@ -113,7 +113,7 @@
         service: "Greeter",
         instance: new GreeterService(),
     })
-    .listen(8080);
+    .listen();
 ```
 
 The contract of the gRPC service is defined in the Protobuf service contracts, that are shown below.

docs/services/sdk/serving.mdx

@@ -32,7 +32,7 @@
 ```
 
 This example shows a router for an unkeyed service with three functions and their respective API paths (`hello`, `callMe`, and `maybe`).
-This means that the `hello` function can be called via `<restate-host>:9090/myServicePath/hello`.
+This means that the `hello` function can be called via `<restate-host>:8080/myServicePath/hello`.
 
 The functions of an unkeyed router have two optional parameters:
 
@@ -53,7 +53,7 @@
 ```
 
 This example shows a router for a keyed service with four functions and their respective API paths (`hello`, `callMe`, `maybe`, and `withSomething`).
-This means that the `hello` function can be called via `<restate-host>:9090/myServicePath/hello`.
+This means that the `hello` function can be called via `<restate-host>:8080/myServicePath/hello`.
 
 The functions of a keyed router have three optional parameters:
 
@@ -77,13 +77,13 @@
     path: "myServicePath",
 };
 ```
-This means that the `hello` function of this service can be called via `<restate-host>:9090/myServicePath/hello`.
+This means that the `hello` function of this service can be called via `<restate-host>:8080/myServicePath/hello`.
 
 **3. Create the server**
 
 Create the server. Then, bind the services with `bindRouter` for unkeyed services and `bindKeyedRouter` for keyed services.
 You need to supply the service path and router. 
-Finally, let the server listen on a specified port (default is `8080`):
+Finally, let the server listen on a specified port (default is `9080`):
 
 ```typescript
 restate
@@ -92,7 +92,7 @@
   .bindRouter(myServiceApi.path, serviceRouter)
   // bind the unkeyed services to the Restate server
   .bindKeyedRouter(myKeyedServiceApi.path, keyedServiceRouter)
-  .listen(8080);
+  .listen();
 ```
 
 
@@ -107,7 +107,7 @@
     service: "Greeter",
     instance: new GreeterService(),
   })
-  .listen(8080);
+  .listen();
 ```
 
 First, call the `createServer()` method to create a new `RestateServer`.
@@ -123,7 +123,7 @@
 ```
 - For the `instance` field, provide an instance of the service implementation. 
 
-Finally, call `listen(port)` to have the RestateServer listen on the specified port for connections and requests.
+Finally, call `listen(port?)` to have the RestateServer listen on the specified port for connections and requests.
 
 </TabItem>
 </Tabs>

docs/tour.mdx

@@ -73,7 +73,7 @@ docker run --name restate_dev --rm -d --network=host ghcr.io/restatedev/restate-
 <TabItem value="mac" label="macOS">
 
 ```shell
-docker run --name restate_dev --rm -d -p 8081:8081 -p 9091:9091 -p 9090:9090 -p 5432:5432 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
+docker run --name restate_dev --rm -d -p 8080:8080 -p 9070:9070 -p 9071:9071 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
 ```
 
 </TabItem>
@@ -96,7 +96,7 @@ You do this by sending a request to the endpoint of the runtime at `http://local
 and providing it with the endpoint of the service `http://localhost:8080`.
 
 ```shell
-curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json' -d '{"uri": "http://localhost:8080"}'
+curl -X POST http://localhost:9070/endpoints -H 'content-type: application/json' -d '{"uri": "http://localhost:9080"}'
 ```
 
 Restate then sends a request to the service endpoint to ask which services and methods run behind this endpoint.
@@ -109,7 +109,7 @@ You do this by sending a request to the endpoint of the runtime at `http://local
 and providing it with the endpoint of the service `http://host.docker.internal:8080`.
 
 ```shell
-curl -X POST http://localhost:8081/endpoints -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:8080"}'
+curl -X POST http://localhost:9070/endpoints -H 'content-type: application/json' -d '{"uri": "http://host.docker.internal:9080"}'
 ```
 
 Restate then sends a request to the service endpoint to ask which services and methods run behind this endpoint.
@@ -147,19 +147,19 @@ When you look at the logs of the runtime you see:
 2023-08-15T13:24:52.879977Z INFO restate_schema_impl::schemas_impl
   Registering endpoint
     restate.service_endpoint.id: bG9jYWxob3N0OjgwODAv
-    restate.service_endpoint.url: http://localhost:8080/
+    restate.service_endpoint.url: http://localhost:9080/
 2023-08-15T13:24:52.880010Z INFO restate_schema_impl::schemas_impl
   Registering service
     rpc.service: "UserSession"
-    restate.service_endpoint.url: http://localhost:8080/
+    restate.service_endpoint.url: http://localhost:9080/
 2023-08-15T13:24:52.881233Z INFO restate_schema_impl::schemas_impl
   Registering service
     rpc.service: "TicketService"
-    restate.service_endpoint.url: http://localhost:8080/
+    restate.service_endpoint.url: http://localhost:9080/
 2023-08-15T13:24:52.881422Z INFO restate_schema_impl::schemas_impl
   Registering service
     rpc.service: "Checkout"
-    restate.service_endpoint.url: http://localhost:8080/
+    restate.service_endpoint.url: http://localhost:9080/
 ```
 
 </details>
@@ -170,7 +170,7 @@ When you look at the logs of the runtime you see:
 Mimic adding a ticket to a cart, by calling `UserSession/addTicket` as follows:
 
 ```shell
-curl -X POST http://localhost:9090/UserSession/addTicket \
+curl -X POST http://localhost:8080/UserSession/addTicket \
   -H 'content-type: application/json' \
   -d '{"key": "123", "request": "456"}'
 ```
@@ -180,7 +180,7 @@ If this prints out `true`, then you have a working setup.
 You can call the `UserSession/checkout` function to proceed with the purchase, as follows:
 
 ```shell
-curl -X POST http://localhost:9090/UserSession/checkout \
+curl -X POST http://localhost:8080/UserSession/checkout \
   -H 'content-type: application/json' \
   -d '{"key": "123"}'
 ```
@@ -516,7 +516,7 @@ const expireTicket = async (
 
 Call the `expireTicket` function with:
 ```shell
-curl -X POST http://localhost:9090/UserSession/expireTicket \
+curl -X POST http://localhost:8080/UserSession/expireTicket \
     -H 'content-type: application/json' \
     -d '{"key": "123", "request": "456"}'
 ```
@@ -1340,7 +1340,7 @@ docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOIN
 <TabItem value="mac" label="macOS">
 
 ```shell
-docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOINT=http://host.docker.internal:4317 -p 8081:8081 -p 9091:9091 -p 9090:9090 -p 5432:5432 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
+docker run --name restate_dev --rm -d -e RESTATE_OBSERVABILITY__TRACING__ENDPOINT=http://host.docker.internal:4317 -p 8080:8080 -p 9070:9070 -p 9071:9071 ghcr.io/restatedev/restate-dist:VAR::RESTATE_DIST_VERSION
 ```
 
 </TabItem>