# Memorystore Memcached (beta)

## Memorystore Memcached Instance

### Enable API

```bash
gcloud services enable servicenetworking.googleapis.com
gcloud services enable memcache.googleapis.com
```

{% hint style="warning" %}
Enabling this API may take a few minutes.
{% endhint %}

### Enable Private Service Access

Memorystore Memcached requires Private Services Access to be enabled. See [Establishing a private services access connection](https://cloud.google.com/memorystore/docs/memcached/establishing-connection) documentation for more information.

Reserve an IP address range to be used in a VPC, so that the Memcached instance's IP address can be allocated within this range:

```bash
gcloud beta compute addresses create reserved-range \
  --global --prefix-length=24 \
  --description=description --network=default \
  --purpose=vpc_peering
```

{% hint style="info" %}
This is a simplified range creation on the `default` VPC network. In a production environment, you should verify what the range should be and which VPC network to allocate in.
{% endhint %}

Establish peering so that Memorystore can allocate the IP address in the reserved range in the VPC.

```bash
gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --ranges=reserved-range --network=default
```

### Create an Instance

Create an instance and attach it to the default VPC.

```bash
gcloud beta memcache instances create orders-cache \
  --node-count=1 --node-cpu=1 --node-memory=1G --region=us-central1
```

{% hint style="warning" %}
Creating a Memcached instance may take a few minutes.
{% endhint %}

### Get Instance IP Address

```bash
gcloud beta memcache instances describe orders-cache \
  --region=us-central1 --format="value(memcacheNodes.host)"
```

{% hint style="warning" %}
The IP address is not a static IP address. If you create the instance, the IP address may be different.
{% endhint %}

### Connect to Instance

See [Memorystore connectivity options](/app-dev/cloud-services/cache.md#connectivity) to see how to connect to a Memorystore instance from different computing environments.

| Computing Environment |                                                                                                                                              |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Compute Engine        | [Guide](https://cloud.google.com/memorystore/docs/memcached/connecting-memcached-instance#connecting-compute-engine)                         |
| Kubernetes Engine     | [Guide](https://cloud.google.com/memorystore/docs/memcached/connecting-memcached-instance#connecting_to_a_memcached_instance_from_a_cluster) |
| App Engine Flexible   | [Additional Configuration](https://cloud.google.com/appengine/docs/flexible/java/using-shared-vpc)                                           |
| App Engine Standard   | [VPC Service Connector](https://cloud.google.com/appengine/docs/standard/java11/connecting-vpc)                                              |
| Cloud Run             | [VPC Service Connector](https://cloud.google.com/run/docs/configuring/connecting-vpc)                                                        |
| Cloud Function        | [VPC Service Connector](https://cloud.google.com/functions/docs/networking/connecting-vpc)                                                   |

You can test quickly by creating a Compute Engine instance in a zone within the same region:

```bash
gcloud compute instances create test-memorystore-vm --zone=us-central1-c
```

SSH into the machine:

```bash
gcloud compute ssh test-memorystore-vm --zone=us-central1-c
```

Install `redis-cli`:

```bash
sudo apt-get update && sudo apt-get install -y telnet
```

Connect to the instance:

```bash
telnet <MEMORYSTORE_MEMCACHED_IP> 11211
```

You can try different Memcached commands, for example, `stats`:

```
Trying ...
Connected to 10.111.98.4.
Escape character is '^]'.
stats
STAT pid 1
STAT uptime 1020
STAT time 1594348128
...
END
quit
Connection closed by foreign host.
```

{% hint style="info" %}
See [Memcached commands](https://github.com/memcached/memcached/wiki/Commands) for more information.
{% endhint %}

## Spring Boot Cache

Spring Boot does not have a built-in Memcached support. However you can use a 3rd party Memcached starter to provide Spring Boot cache support, e.g.:

* <https://github.com/sixhours-team/memcached-spring-boot>

### Dependency

Add the 3rd party Memcached Spring Boot starter:

{% tabs %}
{% tab title="Maven" %}

```bash
<dependency>
    <groupId>io.sixhours</groupId>
    <artifactId>memcached-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>
```

{% endtab %}

{% tab title="Gradle" %}

```bash
compile group: 'io.sixhours', name: 'memcached-spring-boot-starter:2.1.2'
```

{% endtab %}
{% endtabs %}

### Configuration

Configure the Memcached instance to connect to:

{% code title="application.properties" %}

```bash
memcached.cache.servers=<MEMORYSTORE_MEMCACHED_IP>:11211
memcached.cache.provider=static
```

{% endcode %}

### Enable Caching

Turn on caching capability explicitly with the `@EnableCaching` annotation:

```java
@SpringBootApplication
@EnableCaching
class DemoApplication {
  ...
}
```

### Cacheable

Once you configured the Spring Boot with Redis and enabled caching, you can use the `@Cacheable` annotation to cache return values.

```java
@Service
class OrderService {
  private final OrderRepository orderRepository;
  
  public OrderService(OrderRepository orderRepository) {
    this.orderRepository = orderRepository;
  }
  
  @Cacheable("order")
  public Order getOrder(Long id) {
    orderRepository.findById(id);
  }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://spring-gcp.saturnism.me/app-dev/cloud-services/cache/memorystore-memcached.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.