Subir em produção
Uma vez finalizado o processo de configuração e dos testes, sua integração estará pronta para ser colocada em produção.
Veja abaixo as recomendações necessárias para realizar essa mudança de maneira eficaz e segura, garantindo que a integração esteja preparada para realizar transações reais.
Para garantir a segurança de suas transações Payouts, você deve realizar uma criptografia de ponta a ponta. Isso envolve a criação de um mecanismo de chave pública-privada, no qual um request é criptografado por meio de uma chave de segurança, e outra chave é usada para validá-lo.
Para validar as transações, envie a chave pública criada nesta etapa ao Mercado Pago e mantenha a chave privada em segurança no seu sistema. No header X-signature da requisição, envie a assinatura gerada com a chave privada a partir do body e codificada em Base64.
Para criar as chaves pública e privada no Linux ou MacOS, execute o seguinte comando em seu terminal:
terminalopenssl genpkey -algorithm ed25519 -out mpprivate.pem && openssl pkey -in mpprivate.pem -pubout -out mppublic.pem
O comando gera dois arquivos: mppublic.pem, com a chave pública, e mpprivate.pem, com a chave privada.
Para enviar a chave pública ao Mercado Pago, entre em contato com a equipe de Integrações.
A seguir, veja exemplos de geração da assinatura com a chave privada.
package main
import (
"bytes"
"crypto/ed25519"
"crypto/x509"
"encoding/base64"
"encoding/pem"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
// Path to the file storing the private key
privateKeyFile := "private.key"
// Read the private key from the file
privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
if err != nil {
fmt.Println("Error reading private key:", err)
return
}
// Convert the private key bytes to a PrivateKey
privateKey := ed25519.PrivateKey(privateKeyBytes)
// Define your request body
requestBody := []byte(`{"key": "value"}`)
// Sign the request body with the private key
signature := ed25519.Sign(privateKey, requestBody)
// Encode the signature to base64
signatureBase64 := base64.StdEncoding.EncodeToString(signature)
// Create a new HTTP request
req, err := http.NewRequest("POST", "https://example.com/api/endpoint", bytes.NewBuffer(requestBody))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
// Add the X-signature header with the base64 encoded signature
req.Header.Set("X-signature", signatureBase64)
// Send the request
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
// Read the response body
responseBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
// Print the response body
fmt.Println("Response:", string(responseBody))
}
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519
import base64
import json
def main():
# PEM formatted private key
private_key_pem = b'''************************************************'''
try:
# Load the private key from PEM format
private_key = serialization.load_pem_private_key(
private_key_pem,
password=None # No password protection in this example
)
# Ensure we have an Ed25519 private key
if not isinstance(private_key, ed25519.Ed25519PrivateKey):
print("Error: The provided key is not a valid Ed25519 private key")
return
# Define request body as a Python dict
request_data = b'''{REQUEST_BODY}'''
# Use request_data directly as it's already in bytes
request_body = request_data
print("Request body that will be signed:")
print(request_data.decode('utf-8')) # Print the request body
print("\n---\n")
# Sign the request body
signature = private_key.sign(request_body)
# Get the public key
public_key = private_key.public_key()
# Encode signature to base64
signature_base64 = base64.b64encode(signature).decode('utf-8')
# Print results
print(f"Generated signature: {signature_base64}")
print(f"Signature size: {len(signature)} bytes")
# Get key sizes
private_bytes = private_key.private_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PrivateFormat.Raw,
encryption_algorithm=serialization.NoEncryption()
)
public_bytes = public_key.public_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PublicFormat.Raw
)
print(f"Private key size: {len(private_bytes)} bytes")
print(f"Public key size: {len(public_bytes)} bytes")
# Verify the signature
try:
public_key.verify(signature, request_body)
print("✓ Signature verified successfully!")
except Exception:
print("✗ Signature verification failed!")
except Exception as e:
print(f"Error: {str(e)}")
if __name__ == "__main__":
main()
Depois de realizar os testes da sua integração, ative o ambiente de produção da aplicação para obter o Access Token de produção.
-
Acesse Integrações e selecione a aplicação.
-
Clique em Credenciais no menu lateral.
-
Selecione Produção no seletor de ambiente e clique em Ativar ambiente de produção.
-
Informe o setor de atividade e o site do seu negócio.
-
Aceite a Declaração de Privacidade e os Termos e condições. Depois, clique em Ativar.
Copie o Access Token de produção da aplicação e substitua o de teste no backend antes de processar transações reais. Para saber como consultar e proteger essa credencial, veja Credenciais.