Begin by setting up a development environment where you can interact with both the Guardian API and Apache Iceberg. Install necessary tools such as Python, Java, and Apache Spark, which is required for working with Iceberg.

Use Python's `requests` library or similar to make HTTP GET requests to the Guardian API. Ensure you have an API key and understand the API's endpoints and response structure. Fetch the data in JSON format, which is commonly returned by APIs.

```python
import requests

api_key = 'your_api_key'
endpoint = 'https://content.guardianapis.com/search'
params = {'api-key': api_key, 'section': 'world'}
response = requests.get(endpoint, params=params)
data = response.json()
```

Parse the JSON response and transform the data into a tabular format (e.g., CSV or a Pandas DataFrame). This step may involve data cleansing, such as handling missing values, normalizing text fields, or filtering unnecessary information.

```python
import pandas as pd

articles = data['response']['results']
df = pd.json_normalize(articles)
# Cleanse and transform data as needed
```

Set up an Apache Iceberg table in your data lake environment. This typically involves defining the table schema and partitioning strategy using Apache Hive or Spark SQL. Ensure your environment has access to a metastore like Hive Metastore or AWS Glue.

```sql
CREATE TABLE iceberg_db.guardian_articles (
id STRING,
section STRING,
title STRING,
body TEXT,
publication_date DATE
) USING iceberg
PARTITIONED BY (days(publication_date));
```

Convert the transformed data into a columnar storage format such as Parquet using Python or Spark. Parquet is optimal for use with Iceberg due to its efficient storage and query performance characteristics.

```python
df.to_parquet('guardian_articles.parquet', index=False)
```

Use Apache Spark to load the Parquet file into the Iceberg table. This involves writing a Spark job that reads the Parquet file and writes it to the Iceberg table using Spark's Iceberg integration.

```python
from pyspark.sql import SparkSession

spark = SparkSession.builder \
.appName('Load to Iceberg') \
.config('spark.sql.catalog.spark_catalog', 'org.apache.iceberg.spark.SparkCatalog') \
.config('spark.sql.catalog.spark_catalog.type', 'hive') \
.getOrCreate()

df = spark.read.parquet('guardian_articles.parquet')
df.writeTo('iceberg_db.guardian_articles').append()
```

After loading the data, validate the operation by querying the Iceberg table to ensure the data is correctly ingested. Use Spark SQL to perform basic checks like counting records and verifying data integrity.

```sql
SELECT COUNT(*) FROM iceberg_db.guardian_articles;

SELECT * FROM iceberg_db.guardian_articles LIMIT 10;
```

By following these steps, you can effectively move data from the Guardian API to Apache Iceberg without relying on third-party connectors or integrations.