Tích hợp proxy với Google Cloud Functions: hướng dẫn 2024

```html

Google Cloud Functions là nền tảng serverless để chạy mã mà không cần quản lý máy chủ. Khi làm việc với phân tích, tự động hóa yêu cầu API hoặc thu thập dữ liệu, thường cần phải định tuyến lưu lượng qua proxy để vượt qua các chặn, xoay vòng IP và nhắm mục tiêu địa lý. Trong hướng dẫn này, chúng ta sẽ xem xét cách cấu hình proxy trong Cloud Functions trên Python và Node.js với các ví dụ thực tiễn.

Tại sao sử dụng proxy trong Cloud Functions

Google Cloud Functions hoạt động trong môi trường cô lập với các địa chỉ IP chung của các trung tâm dữ liệu Google. Khi có nhiều yêu cầu đến các API hoặc trang web bên ngoài, sẽ phát sinh các vấn đề:

Chặn theo IP — nhiều dịch vụ (Google, Facebook, các chợ điện tử) nhận diện lưu lượng từ các trung tâm dữ liệu và áp dụng giới hạn tần suất hoặc chặn hoàn toàn.
Giới hạn địa lý — để truy cập nội dung chỉ có sẵn ở một số quốc gia nhất định (ví dụ: phân tích giá khu vực trên Wildberries hoặc Ozon).
Giới hạn tần suất — một địa chỉ IP có thể thực hiện một số lượng yêu cầu giới hạn trong một phút. Proxy cho phép phân bổ tải.
Ẩn danh — che giấu nguồn gốc thực sự của các yêu cầu khi làm việc với dữ liệu nhạy cảm hoặc tình báo cạnh tranh.

Các kịch bản sử dụng proxy điển hình trong Cloud Functions:

Phân tích các chợ điện tử (Wildberries, Ozon, Amazon) để theo dõi giá cả của đối thủ
Thu thập dữ liệu từ mạng xã hội (Instagram, TikTok) thông qua API hoặc web scraping
Tự động hóa kiểm tra quảng cáo ở các khu vực khác nhau
Các yêu cầu hàng loạt đến các công cụ tìm kiếm (Google, Yandex) cho phân tích SEO
Kiểm tra các chức năng định vị địa lý của ứng dụng

Các loại proxy nào phù hợp với Cloud Functions

Việc lựa chọn loại proxy phụ thuộc vào nhiệm vụ, ngân sách và yêu cầu về ẩn danh. Dưới đây là sự so sánh các tùy chọn chính:

Loại proxy	Tốc độ	Ẩn danh	Tốt nhất cho
Proxy Datacenter	Cao (50-200 ms)	Trung bình	Phân tích các trang web đơn giản, yêu cầu API, theo dõi SEO
Proxy Residential	Trung bình (200-800 ms)	Cao	Phân tích mạng xã hội, chợ điện tử, vượt qua các hệ thống chống bot
Proxy Di động	Trung bình (300-1000 ms)	Rất cao	Instagram, TikTok, ứng dụng di động, Facebook API

Khuyến nghị về lựa chọn:

Đối với phân tích các chợ điện tử (Wildberries, Ozon, Amazon) — proxy residential với xoay vòng theo yêu cầu, để mỗi yêu cầu đến từ một IP mới.
Đối với yêu cầu API (Google Maps API, OpenWeatherMap) — proxy datacenter với tốc độ cao, nếu không có giới hạn nghiêm ngặt về IP.
Đối với mạng xã hội (Instagram, TikTok) — proxy di động, vì chúng có IP của các nhà mạng di động và hiếm khi bị chặn.
Đối với phân tích SEO (Google, Yandex) — proxy residential với gắn kết địa lý đến khu vực cần thiết.

Cấu hình proxy trong Python (requests, aiohttp)

Python là ngôn ngữ phổ biến nhất cho Cloud Functions khi làm việc với phân tích và tự động hóa. Chúng ta sẽ xem xét tích hợp proxy với các thư viện requests (các yêu cầu đồng bộ) và aiohttp (các yêu cầu bất đồng bộ).

Ví dụ với thư viện requests (HTTP-proxy)

import requests
import os

def parse_with_proxy(request):
    # Lấy dữ liệu proxy từ các biến môi trường
    proxy_host = os.environ.get('PROXY_HOST', 'proxy.example.com')
    proxy_port = os.environ.get('PROXY_PORT', '8080')
    proxy_user = os.environ.get('PROXY_USER', 'username')
    proxy_pass = os.environ.get('PROXY_PASS', 'password')
    
    # Tạo URL proxy với xác thực
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # Thực hiện yêu cầu qua proxy với thời gian chờ
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10,
            headers={'User-Agent': 'Mozilla/5.0'}
        )
        
        # Kiểm tra trạng thái phản hồi
        response.raise_for_status()
        
        return {
            'statusCode': 200,
            'body': response.json(),
            'ip_used': response.headers.get('X-Forwarded-For', 'unknown')
        }
        
    except requests.exceptions.ProxyError as e:
        return {'statusCode': 502, 'error': f'Lỗi proxy: {str(e)}'}
    except requests.exceptions.Timeout:
        return {'statusCode': 504, 'error': 'Thời gian yêu cầu hết hạn'}
    except requests.exceptions.RequestException as e:
        return {'statusCode': 500, 'error': f'Yêu cầu thất bại: {str(e)}'}

Các điểm quan trọng:

Các biến môi trường — lưu trữ dữ liệu proxy (host, port, login, password) trong Secret Manager hoặc các biến môi trường của Cloud Functions, không phải trong mã.
Thời gian chờ — luôn đặt timeout, để chức năng không bị treo khi gặp vấn đề với proxy.
User-Agent — thêm tiêu đề User-Agent, để các yêu cầu trông giống như từ một trình duyệt thực sự.
Xử lý lỗi — xử lý riêng biệt ProxyError (vấn đề với proxy) và Timeout (proxy chậm).

Ví dụ với aiohttp (các yêu cầu bất đồng bộ)

Đối với các nhiệm vụ có tải cao (ví dụ: phân tích 1000+ trang), hãy sử dụng các yêu cầu bất đồng bộ với aiohttp:

import aiohttp
import asyncio
import os

async def fetch_with_proxy(url, proxy_url):
    async with aiohttp.ClientSession() as session:
        try:
            async with session.get(
                url,
                proxy=proxy_url,
                timeout=aiohttp.ClientTimeout(total=10),
                headers={'User-Agent': 'Mozilla/5.0'}
            ) as response:
                return await response.text()
        except aiohttp.ClientProxyConnectionError:
            return {'error': 'Kết nối proxy thất bại'}
        except asyncio.TimeoutError:
            return {'error': 'Thời gian yêu cầu hết hạn'}

def parse_multiple_urls(request):
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    urls = [
        'https://example.com/page1',
        'https://example.com/page2',
        'https://example.com/page3'
    ]
    
    # Chạy các yêu cầu bất đồng bộ song song
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    
    tasks = [fetch_with_proxy(url, proxy_url) for url in urls]
    results = loop.run_until_complete(asyncio.gather(*tasks))
    
    return {'statusCode': 200, 'results': results}

Cách tiếp cận bất đồng bộ cho phép thực hiện 10-100 yêu cầu song song qua proxy, điều này rất quan trọng cho việc phân tích khối lượng dữ liệu lớn trong thời gian thực thi Cloud Functions bị giới hạn (tối đa 9 phút).

Làm việc với SOCKS5-proxy

Một số nhà cung cấp proxy cung cấp SOCKS5-proxy để làm việc đáng tin cậy hơn với lưu lượng UDP hoặc vượt qua các chặn. Để làm việc với SOCKS5 trong Python, hãy sử dụng thư viện requests[socks]:

# Thêm vào requirements.txt:
# requests[socks]

import requests

def use_socks5_proxy(request):
    proxy_url = f"socks5://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    response = requests.get(
        'https://api.ipify.org?format=json',
        proxies=proxies,
        timeout=10
    )
    
    return {'statusCode': 200, 'ip': response.json()}

Cấu hình proxy trong Node.js (axios, node-fetch)

Node.js là ngôn ngữ phổ biến thứ hai cho Cloud Functions. Chúng ta sẽ xem xét tích hợp proxy với các thư viện axios và node-fetch.

Ví dụ với axios

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

exports.parseWithProxy = async (req, res) => {
  const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
  
  const agent = new HttpsProxyAgent(proxyUrl);
  
  try {
    const response = await axios.get('https://api.example.com/data', {
      httpsAgent: agent,
      timeout: 10000,
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
      }
    });
    
    res.status(200).json({
      success: true,
      data: response.data,
      proxyUsed: proxyUrl.split('@')[1] // Trả về host:port không có mật khẩu
    });
    
  } catch (error) {
    if (error.code === 'ECONNREFUSED') {
      res.status(502).json({ error: 'Kết nối proxy bị từ chối' });
    } else if (error.code === 'ETIMEDOUT') {
      res.status(504).json({ error: 'Thời gian chờ proxy' });
    } else {
      res.status(500).json({ error: error.message });
    }
  }
};

Các phụ thuộc cho package.json:

{
  "dependencies": {
    "axios": "^1.6.0",
    "https-proxy-agent": "^7.0.2"
  }
}

Ví dụ với node-fetch và SOCKS5

const fetch = require('node-fetch');
const { SocksProxyAgent } = require('socks-proxy-agent');

exports.fetchWithSocks5 = async (req, res) => {
  const proxyUrl = `socks5://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
  
  const agent = new SocksProxyAgent(proxyUrl);
  
  try {
    const response = await fetch('https://api.ipify.org?format=json', {
      agent,
      timeout: 10000
    });
    
    const data = await response.json();
    
    res.status(200).json({
      success: true,
      yourIP: data.ip
    });
    
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

Các phụ thuộc cho SOCKS5:

{
  "dependencies": {
    "node-fetch": "^2.7.0",
    "socks-proxy-agent": "^8.0.2"
  }
}

Xác thực proxy: tên đăng nhập/mật khẩu và danh sách trắng IP

Có hai phương pháp xác thực chính khi làm việc với proxy:

1. Xác thực bằng tên đăng nhập và mật khẩu

Phương pháp phổ biến nhất là truyền thông tin xác thực trong URL proxy:

http://username:password@proxy.example.com:8080

Ưu điểm: Dễ dàng cấu hình, không yêu cầu IP nguồn cố định.

Nhược điểm: Thông tin xác thực được truyền trong mỗi yêu cầu, có một chút overhead.

2. Xác thực bằng danh sách trắng IP

Một số nhà cung cấp cho phép thêm địa chỉ IP của Cloud Functions vào danh sách trắng. Vấn đề: Cloud Functions sử dụng các IP động từ nhóm Google Cloud.

Giải pháp: Sử dụng Cloud NAT để định tuyến lưu lượng ra ngoài qua một IP tĩnh:

Tạo mạng VPC và subnet trong Google Cloud
Cấu hình Cloud NAT với việc dự phòng IP tĩnh
Kết nối Cloud Functions với VPC Connector
Thêm IP tĩnh vào danh sách trắng của nhà cung cấp proxy

Sau khi cấu hình, proxy không yêu cầu tên đăng nhập và mật khẩu:

proxies = {
    'http': 'http://proxy.example.com:8080',
    'https': 'http://proxy.example.com:8080'
}

Khuyến nghị: Đối với hầu hết các trường hợp, hãy sử dụng xác thực bằng tên đăng nhập/mật khẩu — điều này đơn giản hơn và không yêu cầu chi phí bổ sung cho Cloud NAT (từ $0.044/giờ + lưu lượng).

Xoay vòng IP và quản lý nhóm proxy

Khi phân tích khối lượng dữ liệu lớn, việc sử dụng xoay vòng IP là rất quan trọng để tránh bị chặn. Có một số cách tiếp cận:

1. Xoay vòng ở phía nhà cung cấp (Rotating Proxies)

Nhiều nhà cung cấp cung cấp rotating proxies — một endpoint duy nhất, tự động thay đổi IP với mỗi yêu cầu hoặc theo bộ đếm thời gian:

# Một endpoint, IP tự động thay đổi
proxy_url = "http://username:password@rotating.proxy.com:8080"

# Mỗi yêu cầu đến từ một IP mới
for i in range(100):
    response = requests.get('https://api.ipify.org', proxies={'http': proxy_url})
    print(f"Yêu cầu {i}: IP = {response.text}")

Ưu điểm: Không cần quản lý nhóm proxy thủ công, tích hợp đơn giản.

Nhược điểm: Không kiểm soát được các IP cụ thể, có thể đắt hơn.

2. Quản lý nhóm proxy thủ công

Nếu bạn có danh sách các proxy tĩnh, hãy thực hiện xoay vòng ở cấp độ mã:

import random
import requests

# Nhóm proxy (có thể tải từ Secret Manager)
PROXY_POOL = [
    "http://user:pass@proxy1.example.com:8080",
    "http://user:pass@proxy2.example.com:8080",
    "http://user:pass@proxy3.example.com:8080",
]

def get_random_proxy():
    return random.choice(PROXY_POOL)

def parse_with_rotation(urls):
    results = []
    
    for url in urls:
        proxy = get_random_proxy()
        
        try:
            response = requests.get(
                url,
                proxies={'http': proxy, 'https': proxy},
                timeout=10
            )
            results.append({
                'url': url,
                'status': response.status_code,
                'proxy': proxy.split('@')[1]
            })
        except Exception as e:
            # Nếu proxy không hoạt động, hãy thử một cái khác
            proxy = get_random_proxy()
            response = requests.get(url, proxies={'http': proxy, 'https': proxy})
            results.append({'url': url, 'status': response.status_code})
    
    return results

3. Proxy dựa trên phiên (sticky sessions)

Đối với các nhiệm vụ cần giữ một IP trong phiên (ví dụ: xác thực trên trang web), hãy sử dụng ID phiên trong URL proxy:

# Thêm ID phiên vào tên đăng nhập
import uuid

session_id = str(uuid.uuid4())
proxy_url = f"http://username-session-{session_id}:password@proxy.example.com:8080"

# Tất cả các yêu cầu với session_id này sẽ đi qua một IP
session = requests.Session()
session.proxies = {'http': proxy_url, 'https': proxy_url}

# Xác thực
session.post('https://example.com/login', data={'user': 'test', 'pass': '123'})

# Các yêu cầu tiếp theo trong cùng một phiên
session.get('https://example.com/dashboard')

Xử lý lỗi và thời gian chờ

Khi làm việc với proxy trong Cloud Functions, việc xử lý lỗi đúng cách là rất quan trọng để không mất dữ liệu và không vượt quá giới hạn thời gian thực thi.

Các loại lỗi và cách xử lý

Lỗi	Nguyên nhân	Giải pháp
ProxyError	Proxy không khả dụng hoặc thông tin xác thực không chính xác	Chuyển sang proxy khác trong nhóm
Timeout	Proxy chậm hoặc máy chủ quá tải	Đặt thời gian chờ 5-10 giây, thử lại với IP khác
407 Proxy Authentication Required	Tên đăng nhập/mật khẩu không chính xác	Kiểm tra thông tin xác thực trong các biến môi trường
429 Too Many Requests	Giới hạn tần suất trên trang web mục tiêu	Thêm độ trễ giữa các yêu cầu, sử dụng nhiều IP hơn
403 Forbidden	IP proxy bị chặn bởi trang web	Thay đổi IP, sử dụng residential thay vì datacenter

Ví dụ về xử lý lỗi toàn diện

import requests
import time
from requests.exceptions import ProxyError, Timeout, RequestException

def fetch_with_retry(url, proxy_pool, max_retries=3):
    """
    Yêu cầu với tự động retry và thay đổi proxy khi có lỗi
    """
    for attempt in range(max_retries):
        proxy = random.choice(proxy_pool)
        
        try:
            response = requests.get(
                url,
                proxies={'http': proxy, 'https': proxy},
                timeout=10,
                headers={'User-Agent': 'Mozilla/5.0'}
            )
            
            # Kiểm tra mã trạng thái
            if response.status_code == 200:
                return {'success': True, 'data': response.text, 'proxy': proxy}
            elif response.status_code == 429:
                # Giới hạn tần suất — chờ và thử lại
                time.sleep(2 ** attempt)  # Tăng dần thời gian chờ
                continue
            elif response.status_code == 403:
                # IP bị chặn — thay đổi proxy
                continue
            else:
                return {'success': False, 'status': response.status_code}
                
        except ProxyError:
            # Proxy không hoạt động — thử cái tiếp theo
            print(f"Proxy {proxy} thất bại, thử cái khác...")
            continue
        except Timeout:
            # Thời gian chờ — thử với proxy khác
            print(f"Thời gian chờ với {proxy}, thử lại...")
            continue
        except RequestException as e:
            # Các lỗi khác
            print(f"Yêu cầu thất bại: {e}")
            if attempt == max_retries - 1:
                return {'success': False, 'error': str(e)}
            continue
    
    return {'success': False, 'error': 'Đã vượt quá số lần thử tối đa'}

Cấu hình thời gian chờ trong Cloud Functions

Cloud Functions có giới hạn thời gian thực thi (mặc định là 60 giây, tối đa là 540 giây). Hãy cân nhắc điều này khi cấu hình thời gian chờ cho proxy:

Thời gian chờ kết nối — thời gian để thiết lập kết nối với proxy (khuyến nghị 5 giây)
Thời gian chờ đọc — thời gian để nhận phản hồi từ máy chủ mục tiêu qua proxy (khuyến nghị 10-15 giây)
Tổng thời gian chờ — tổng thời gian cho toàn bộ yêu cầu (nên nhỏ hơn thời gian chờ của chức năng)

# Python: thời gian chờ riêng biệt
response = requests.get(
    url,
    proxies=proxies,
    timeout=(5, 15)  # (thời gian chờ kết nối, thời gian chờ đọc)
)

# Node.js với axios
const response = await axios.get(url, {
  httpsAgent: agent,
  timeout: 10000  // tổng thời gian chờ tính bằng mili giây
});

Các thực tiễn tốt nhất và tối ưu hóa hiệu suất

Khuyến nghị cho việc làm việc hiệu quả với proxy trong Cloud Functions:

1. Sử dụng các biến môi trường cho thông tin xác thực

Không bao giờ lưu trữ tên đăng nhập và mật khẩu proxy trong mã. Sử dụng Secret Manager hoặc các biến môi trường:

# Tạo bí mật trong Google Cloud
gcloud secrets create proxy-credentials \
    --data-file=proxy-config.json

# Cung cấp quyền truy cập cho Cloud Functions
gcloud secrets add-iam-policy-binding proxy-credentials \
    --member=serviceAccount:PROJECT_ID@appspot.gserviceaccount.com \
    --role=roles/secretmanager.secretAccessor

# Đọc bí mật trong mã
from google.cloud import secretmanager
import json

def get_proxy_config():
    client = secretmanager.SecretManagerServiceClient()
    name = f"projects/{PROJECT_ID}/secrets/proxy-credentials/versions/latest"
    response = client.access_secret_version(request={"name": name})
    return json.loads(response.payload.data.decode('UTF-8'))

2. Lưu trữ kết quả phân tích

Sử dụng Cloud Storage hoặc Firestore để lưu trữ dữ liệu, để không thực hiện các yêu cầu lặp lại qua proxy:

import hashlib
from google.cloud import storage

def fetch_with_cache(url, proxy):
    # Tạo khóa cache dựa trên URL
    cache_key = hashlib.md5(url.encode()).hexdigest()
    
    # Kiểm tra cache trong Cloud Storage
    bucket = storage.Client().bucket('my-cache-bucket')
    blob = bucket.blob(f"cache/{cache_key}.json")
    
    if blob.exists():
        # Trả về dữ liệu đã lưu trữ
        return json.loads(blob.download_as_text())
    
    # Thực hiện yêu cầu qua proxy
    response = requests.get(url, proxies={'http': proxy})
    data = response.json()
    
    # Lưu vào cache
    blob.upload_from_string(json.dumps(data))
    
    return data

3. Giám sát và ghi log

Theo dõi hiệu suất của proxy và tần suất lỗi thông qua Cloud Logging:

import logging
import time

def fetch_with_logging(url, proxy):
    start_time = time.time()
    
    try:
        response = requests.get(url, proxies={'http': proxy}, timeout=10)
        duration = time.time() - start_time
        
        logging.info({
            'url': url,
            'proxy': proxy.split('@')[1],
            'status': response.status_code,
            'duration': duration,
            'success': True
        })
        
        return response
        
    except Exception as e:
        duration = time.time() - start_time
        
        logging.error({
            'url': url,
            'proxy': proxy.split('@')[1],
            'error': str(e),
            'duration': duration,
            'success': False
        })
        
        raise

4. Tối ưu hóa khởi động lạnh

Cloud Functions có độ trễ khởi động lạnh (cold start). Giảm thiểu các phụ thuộc và sử dụng các phiên bản thư viện tối thiểu:

# requirements.txt — chỉ các thư viện cần thiết
requests==2.31.0
# Tránh các thư viện nặng như pandas, nếu không cần thiết

Sử dụng các biến toàn cục để tái sử dụng các kết nối:

# Tạo phiên một lần khi khởi động lạnh
session = requests.Session()
session.proxies = {'http': PROXY_URL, 'https': PROXY_URL}

def parse_data(request):
    # Tái sử dụng phiên giữa các lần gọi
    response = session.get('https://api.example.com/data')
    return response.json()

5. Gắn kết địa lý cho proxy

Đối với các nhiệm vụ có nhắm mục tiêu địa lý (ví dụ: phân tích giá khu vực), hãy sử dụng proxy gắn kết với một quốc gia hoặc thành phố cụ thể:

# Ví dụ với proxy residential, nơi có thể chỉ định quốc gia trong tên đăng nhập
proxy_url = f"http://username-country-ru:password@proxy.example.com:8080"

# Hoặc sử dụng các endpoint khác nhau cho các quốc gia khác nhau
PROXIES_BY_COUNTRY = {
    'RU': 'http://user:pass@ru.proxy.example.com:8080',
    'US': 'http://user:pass@us.proxy.example.com:8080',
    'DE': 'http://user:pass@de.proxy.example.com:8080'
}

def parse_by_country(country_code):
    proxy = PROXIES_BY_COUNTRY.get(country_code)
    response = requests.get('https://example.com', proxies={'http': proxy})
    return response.text

Kết luận

Tích hợp proxy với Google Cloud Functions mở ra nhiều cơ hội cho phân tích, tự động hóa và làm việc với API mà không bị giới hạn bởi IP. Những điểm chính cần lưu ý: xử lý lỗi đúng cách với logic retry, sử dụng thời gian chờ để ngăn chặn tình trạng treo, xoay vòng IP để tránh bị chặn và lưu trữ thông tin xác thực một cách an toàn trong Secret Manager.

Đối với hầu hết các nhiệm vụ phân tích và tự động hóa, lựa chọn tối ưu sẽ là proxy residential — chúng cung cấp độ ẩn danh cao và tỷ lệ chặn thấp nhờ vào việc sử dụng IP của người dùng thực. Đối với việc làm việc với mạng xã hội và ứng dụng di động, chúng tôi khuyên dùng proxy di động, có IP của các nhà mạng di động và gần như không bị chặn bởi các nền tảng như Instagram và TikTok.

Với cấu hình đúng cách, Cloud Functions với proxy cung cấp một giải pháp có thể mở rộng và tiết kiệm cho việc xử lý khối lượng dữ liệu lớn mà không cần quản lý hạ tầng.

```

Tích hợp proxy với Google Cloud Functions: cấu hình cho việc phân tích và tự động hóa