Why does adding Nmap port scanning inside a Celery task slow down my FastAPI + SQLAlchemy + PostgreSQL app?

I am building a scanning service using FastAPI + Celery + PostgreSQL + SQLAlchemy + Nmap.

I have a Celery task that performs WHOIS, DNS lookups, IP lookups, and then port scanning using python-nmap. The issue is that when I add the port scanning part inside my Celery task, my entire API becomes very slow (requests take 10–20 seconds).

If I restart the application without triggering the task, the API works fine and responds in milliseconds.

Here’s a simplified version of my code:

@tasks_router.post(
    "/create",
    response_model=schemas.TaskRead,
    summary="Create a new scan task",
    description=(
            "Create a task for scanning an entity (domain or IP). The task is queued to the background worker.\n\n"
            "- For domains: performs WHOIS and DNS lookups.\n"
            "- For IPs: performs geolocation lookup via ipinfo.io."
    ),
)
def create_task(payload: schemas.TaskCreate, db: Session = Depends(get_db)):
    entity = payload.entity
    is_domain = not entity.replace(".", "").isdigit()  # crude check (schema regex already validated)

    task = models.IpDomainScanTask(
        user_id=payload.user_id,
        entity=entity,
        is_domain=is_domain,
        status=models.TaskStatus.pending,
        progress_message="Task created"
    )
    db.add(task)
    db.commit()
    db.refresh(task)

    # Send to Celery worker
    try:
        scan_entity.delay(str(task.id))
    except Exception as e:
        task.progress_message = f"Queueing failed: {e}"
        task.status = models.TaskStatus.failed
        db.commit()
        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Task queue unavailable")

    return task

import nmap

def scan_ip(ip: str, mode: str = "fast") -> dict:
    scanner = nmap.PortScanner(nmap_search_path=[r"C:\Program Files (x86)\Nmap\nmap.exe"])
    arguments = "--top-ports 100 -sV --version-light -T4" if mode == "fast" else "-A"
    scanner.scan(ip, arguments=arguments)
    results = {"host": ip, "ports": []}
    for host in scanner.all_hosts():
        for proto in scanner[host].all_protocols():
            for port in scanner[host][proto]:
                port_info = scanner[host][proto][port]
                results["ports"].append({
                    "port": port,
                    "service": port_info.get("name", ""),
                    "state": port_info.get("state", "")
                })
    return results

And the Celery task:

@celery.task(name="tasks.scan_entity")
def scan_entity(task_id: str):
    db = CelerySessionLocal()
    try:
        try:
            task_uuid = uuid.UUID(task_id)
        except Exception:
            return {"error": "Invalid task id"}
        task = (
            db.query(models.IpDomainScanTask)
            .filter(models.IpDomainScanTask.id == task_id)
            .first()
        )
        #,....other scaning

        # when ever i add this block my all API's get very slow if remove it my api call is fast
        update_progress(db, task, "Starting port scan")
        db.close()
        os_records = []
        port_records = []
        for idx, ip in enumerate(['1.1.1.1.1'], start=1):

            # IP lookup

            # Port scanning
            scan_results = scan_ip(ip)

            # Store OS detection results
            for os_info in scan_results.get("os", []):
                os_record = models.OperatingSystem(
                    task_id=task.id,
                    ip=ip,
                    name=os_info["name"],
                    accuracy=os_info["accuracy"]
                )
                os_records.append(os_record)

            # Store port scan results
            for port_info in scan_results.get("ports", []):
                port_record = models.PortScan(
                    task_id=task.id,
                    ip=ip,
                    port=port_info["port"],
                    protocol=port_info["protocol"],
                    state=port_info["state"],
                    service=port_info["service"],
                    product=port_info["product"],
                    version=port_info["version"],
                    extra_info=port_info["extra_info"]
                )
                port_records.append(port_record)
            # update_progress(db, task, f"Port scan {idx}/{len(checkip)} completed")
        db = CelerySessionLocal()  # Reconnect to the database after closing it
        db.add_all(os_records)
        db.add_all(port_records)
        db.commit()

        update_progress(db, task, "Scan completed successfully", models.TaskStatus.completed)
        db.close()
        return {"task_id": str(task.id), "status": "completed"}
    except Exception as e:
        task = (
            db.query(models.IpDomainScanTask)
            .filter(models.IpDomainScanTask.id == task_id)
            .first()
        )
        update_progress(db, task, f"Scan failed: {str(e)}", models.TaskStatus.failed)
        return {"task_id": str(task.id), "status": "failed", "error": str(e)}
    finally:
        db.close()

Problem:

• Without the port scanning block, everything works fast.
• With port scanning inside Celery, my FastAPI endpoints become very slow (10–20s).
• Even requests unrelated to the task are affected.

My setup:

• FastAPI (running with Uvicorn)
• Celery (with Redis as broker)
• PostgreSQL + SQLAlchemy
• python-nmap

Question:

• Why does running Nmap scans inside a Celery worker cause my API to slow down?
• Is this a DB session/connection pool issue (since I close/reopen SessionLocal)?
• Or is it because Nmap blocks the event loop or consumes too many resources?
• What’s the best practice to run heavy I/O tasks (like port scanning) in Celery without affecting FastAPI performance?