Begin by setting up your development environment. Ensure you have Python installed on your machine, as it will be used to interact with both the Guardian API and Redis. Additionally, install necessary Python packages such as `requests` for making HTTP requests and `redis` for interacting with your Redis database.

Sign up for an API key from the Guardian API portal if you haven"t already. This key will be used to authenticate your requests. Make sure to check the Guardian API documentation for any specific requirements or limitations related to data access or usage.

Create a Python script to fetch data from the Guardian API. Use the `requests` library to make a GET request to the API endpoint. Include your API key in the request header or parameters as specified by the Guardian API documentation. Parse the API response, typically in JSON format, and extract the desired data fields.

```python
import requests

# Example function to fetch data
def fetch_guardian_data(api_key, endpoint):
headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get(endpoint, headers=headers)
response.raise_for_status() # Raise an error on bad response
return response.json() # Parse JSON response
```

Install Redis on your local machine or set up a remote Redis server. Follow the official Redis installation guide appropriate for your operating system. Once installed, start the Redis server and ensure it is running correctly. You can configure Redis by editing the `redis.conf` file if needed, although default settings usually suffice for basic operations.

Use the `redis` Python package to connect to your Redis server. Initialize a Redis client instance in your script by specifying the host and port number. Test the connection by performing a simple set and get operation.

```python
import redis

# Connect to Redis
r = redis.Redis(host='localhost', port=6379, db=0)

# Test connection
r.set('test_key', 'test_value')
print(r.get('test_key')) # Should output: b'test_value'
```

Transform the data fetched from the Guardian API into a format suitable for Redis storage. Decide on a key structure that makes sense for your use case (e.g., using article IDs as keys). Use Redis commands to store the data. You can use different Redis data types such as strings, hashes, or lists depending on the nature of your data.

```python
# Example function to store data in Redis
def store_data_in_redis(data):
for item in data['response']['results']:
article_id = item['id']
r.set(article_id, str(item)) # Store article data as a string
```

Implement a mechanism to periodically update the data in Redis. You can use a simple loop with a delay or a more sophisticated scheduling library like `schedule` or `APScheduler` to trigger data fetching and storing operations at regular intervals.

```python
import time

# Example of simple loop to schedule updates
while True:
data = fetch_guardian_data(api_key, endpoint)
store_data_in_redis(data)
time.sleep(3600) # Wait for 1 hour before the next update
```

By following these steps, you can efficiently move data from the Guardian API to Redis without relying on third-party connectors or integrations. Make sure to handle errors and exceptions properly to ensure the robustness of your implementation.