Что такое Elastic IP?

Elastic IP в AWS

Elastic IP — это статический публичный IPv4-адрес, предоставляемый AWS, который остаётся неизменным и может быть переназначен между различными экземплярами EC2 в одном регионе. В отличие от обычных публичных IP-адресов, которые меняются при остановке и запуске инстанса, Elastic IP не меняется.

Основные характеристики

• Статичность — адрес не меняется при перезагрузке или остановке инстанса
• Переносимость — может быть переназначен от одного инстанса к другому за секунды
• Региональность — адрес привязан к конкретному регионту AWS
• Платность — AWS взимает плату за неиспользуемый Elastic IP (даже если он не назначен ни одному инстансу)

Когда используется Elastic IP

1. DNS-записи — когда нужен постоянный IP для A-записей в DNS
2. Failover — быстрое переключение между инстансами при отказе одного
3. VPN/SSH — постоянный адрес для удалённого доступа
4. Внешние API — когда клиенты обращаются к вашему сервису по конкретному IP (whitelisting)

Пример работы с Elastic IP через boto3

import boto3
from botocore.exceptions import ClientError

class ElasticIPManager:
    def __init__(self, region_name=us-east-1):
        self.ec2_client = boto3.client(ec2, region_name=region_name)
    
    def allocate_elastic_ip(self, domain=vpc):
        """Выделить новый Elastic IP адрес"""
        try:
            response = self.ec2_client.allocate_address(Domain=domain)
            return {
                allocation_id: response[AllocationId],
                public_ip: response[PublicIp]
            }
        except ClientError as e:
            print(f"Ошибка при выделении IP: {e}")
            return None
    
    def associate_elastic_ip(self, instance_id, allocation_id, private_ip=None):
        """Привязать Elastic IP к инстансу"""
        try:
            params = {
                InstanceId: instance_id,
                AllocationId: allocation_id
            }
            if private_ip:
                params[PrivateIpAddress] = private_ip
            
            response = self.ec2_client.associate_address(**params)
            return response.get(AssociationId)
        except ClientError as e:
            print(f"Ошибка при привязке IP: {e}")
            return None
    
    def disassociate_elastic_ip(self, association_id):
        """Отвязать Elastic IP от инстанса"""
        try:
            self.ec2_client.disassociate_address(AssociationId=association_id)
            return True
        except ClientError as e:
            print(f"Ошибка при отвязке IP: {e}")
            return False
    
    def release_elastic_ip(self, allocation_id):
        """Освободить Elastic IP (полностью удалить)"""
        try:
            self.ec2_client.release_address(AllocationId=allocation_id)
            return True
        except ClientError as e:
            print(f"Ошибка при освобождении IP: {e}")
            return False
    
    def list_elastic_ips(self):
        """Список всех Elastic IP в регионе"""
        try:
            response = self.ec2_client.describe_addresses()
            ips = []
            for addr in response[Addresses]:
                ip_info = {
                    allocation_id: addr.get(AllocationId),
                    public_ip: addr.get(PublicIp),
                    instance_id: addr.get(InstanceId),
                    association_id: addr.get(AssociationId),
                    in_use: InstanceId in addr
                }
                ips.append(ip_info)
            return ips
        except ClientError as e:
            print(f"Ошибка при получении списка IP: {e}")
            return []
    
    def failover_elastic_ip(self, allocation_id, new_instance_id):
        """Переназначить Elastic IP на другой инстанс (failover)"""
        try:
            # Получаем текущую ассоциацию
            addresses = self.ec2_client.describe_addresses(
                AllocationIds=[allocation_id]
            )[Addresses]
            
            if not addresses:
                print("IP не найден")
                return False
            
            current_assoc_id = addresses[0].get(AssociationId)
            
            # Отвязываем от старого инстанса
            if current_assoc_id:
                self.disassociate_elastic_ip(current_assoc_id)
            
            # Привязываем к новому
            return self.associate_elastic_ip(new_instance_id, allocation_id) is not None
        except ClientError as e:
            print(f"Ошибка при failover: {e}")
            return False

# Пример использования
if __name__ == __main__:
    manager = ElasticIPManager()
    
    # Выделяем новый IP
    eip = manager.allocate_elastic_ip()
    print(f"Выделен IP: {eip[public_ip]}")
    
    # Привязываем к инстансу
    association_id = manager.associate_elastic_ip(
        instance_id=i-1234567890abcdef0,
        allocation_id=eip[allocation_id]
    )
    print(f"Привязан к инстансу. Association ID: {association_id}")
    
    # Просматриваем все IP
    all_ips = manager.list_elastic_ips()
    for ip_info in all_ips:
        print(ip_info)
    
    # Failover на другой инстанс
    manager.failover_elastic_ip(
        allocation_id=eip[allocation_id],
        new_instance_id=i-0987654321fedcba0
    )

Разница между Elastic IP и Public IP

Лучшие практики

1. Освобождайте неиспользуемые IP — каждый неиспользуемый Elastic IP стоит денег
2. Используйте для важных сервисов — для критичных приложений, требующих постоянного адреса
3. Комбинируйте с load balancer — для балансировки нагрузки используйте Application Load Balancer вместо Elastic IP
4. Мониторьте лимиты — AWS по умолчанию ограничивает количество Elastic IP на аккаунт

Elastic IP является важным инструментом для высокодоступных и надёжных архитектур в AWS.